2 * QEMU S390x KVM floating interrupt controller (flic)
4 * Copyright 2014 IBM Corp.
5 * Author(s): Jens Freimann <jfrei@linux.vnet.ibm.com>
6 * Cornelia Huck <cornelia.huck@de.ibm.com>
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
13 #include "qemu/osdep.h"
14 #include <sys/ioctl.h>
15 #include "qemu/error-report.h"
16 #include "hw/sysbus.h"
17 #include "sysemu/kvm.h"
18 #include "migration/qemu-file.h"
19 #include "hw/s390x/s390_flic.h"
20 #include "hw/s390x/adapter.h"
23 #define FLIC_SAVE_INITIAL_SIZE getpagesize()
24 #define FLIC_FAILED (-1UL)
25 #define FLIC_SAVEVM_VERSION 1
27 typedef struct KVMS390FLICState {
28 S390FLICState parent_obj;
33 DeviceState *s390_flic_kvm_create(void)
35 DeviceState *dev = NULL;
38 dev = qdev_create(NULL, TYPE_KVM_S390_FLIC);
39 object_property_add_child(qdev_get_machine(), TYPE_KVM_S390_FLIC,
46 * flic_get_all_irqs - store all pending irqs in buffer
47 * @buf: pointer to buffer which is passed to kernel
48 * @len: length of buffer
49 * @flic: pointer to flic device state
51 * Returns: -ENOMEM if buffer is too small,
52 * -EINVAL if attr.group is invalid,
53 * -EFAULT if copying to userspace failed,
54 * on success return number of stored interrupts
56 static int flic_get_all_irqs(KVMS390FLICState *flic,
59 struct kvm_device_attr attr = {
60 .group = KVM_DEV_FLIC_GET_ALL_IRQS,
61 .addr = (uint64_t) buf,
66 rc = ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr);
68 return rc == -1 ? -errno : rc;
71 static void flic_enable_pfault(KVMS390FLICState *flic)
73 struct kvm_device_attr attr = {
74 .group = KVM_DEV_FLIC_APF_ENABLE,
78 rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
81 fprintf(stderr, "flic: couldn't enable pfault\n");
85 static void flic_disable_wait_pfault(KVMS390FLICState *flic)
87 struct kvm_device_attr attr = {
88 .group = KVM_DEV_FLIC_APF_DISABLE_WAIT,
92 rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
95 fprintf(stderr, "flic: couldn't disable pfault\n");
99 /** flic_enqueue_irqs - returns 0 on success
100 * @buf: pointer to buffer which is passed to kernel
101 * @len: length of buffer
102 * @flic: pointer to flic device state
104 * Returns: -EINVAL if attr.group is unknown
106 static int flic_enqueue_irqs(void *buf, uint64_t len,
107 KVMS390FLICState *flic)
110 struct kvm_device_attr attr = {
111 .group = KVM_DEV_FLIC_ENQUEUE,
112 .addr = (uint64_t) buf,
116 rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
118 return rc ? -errno : 0;
121 int kvm_s390_inject_flic(struct kvm_s390_irq *irq)
123 static KVMS390FLICState *flic;
125 if (unlikely(!flic)) {
126 flic = KVM_S390_FLIC(s390_get_flic());
128 return flic_enqueue_irqs(irq, sizeof(*irq), flic);
132 * __get_all_irqs - store all pending irqs in buffer
133 * @flic: pointer to flic device state
134 * @buf: pointer to pointer to a buffer
135 * @len: length of buffer
137 * Returns: return value of flic_get_all_irqs
138 * Note: Retry and increase buffer size until flic_get_all_irqs
139 * either returns a value >= 0 or a negative error code.
140 * -ENOMEM is an exception, which means the buffer is too small
141 * and we should try again. Other negative error codes can be
142 * -EFAULT and -EINVAL which we ignore at this point
144 static int __get_all_irqs(KVMS390FLICState *flic,
150 /* returns -ENOMEM if buffer is too small and number
151 * of queued interrupts on success */
152 r = flic_get_all_irqs(flic, *buf, len);
157 *buf = g_try_realloc(*buf, len);
161 } while (r == -ENOMEM && len <= KVM_S390_FLIC_MAX_BUFFER);
166 static int kvm_s390_register_io_adapter(S390FLICState *fs, uint32_t id,
167 uint8_t isc, bool swap,
170 struct kvm_s390_io_adapter adapter = {
173 .maskable = is_maskable,
176 KVMS390FLICState *flic = KVM_S390_FLIC(fs);
178 struct kvm_device_attr attr = {
179 .group = KVM_DEV_FLIC_ADAPTER_REGISTER,
180 .addr = (uint64_t)&adapter,
183 if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
188 r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
190 ret = r ? -errno : 0;
194 static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id,
195 uint64_t map_addr, bool do_map)
197 struct kvm_s390_io_adapter_req req = {
199 .type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,
202 struct kvm_device_attr attr = {
203 .group = KVM_DEV_FLIC_ADAPTER_MODIFY,
204 .addr = (uint64_t)&req,
206 KVMS390FLICState *flic = KVM_S390_FLIC(fs);
209 if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
214 r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
215 return r ? -errno : 0;
218 static int kvm_s390_add_adapter_routes(S390FLICState *fs,
219 AdapterRoutes *routes)
222 uint64_t ind_offset = routes->adapter.ind_offset;
224 for (i = 0; i < routes->num_routes; i++) {
225 ret = kvm_irqchip_add_adapter_route(kvm_state, &routes->adapter);
229 routes->gsi[i] = ret;
230 routes->adapter.ind_offset++;
232 kvm_irqchip_commit_routes(kvm_state);
234 /* Restore passed-in structure to original state. */
235 routes->adapter.ind_offset = ind_offset;
239 kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
242 routes->adapter.ind_offset = ind_offset;
246 static void kvm_s390_release_adapter_routes(S390FLICState *fs,
247 AdapterRoutes *routes)
251 for (i = 0; i < routes->num_routes; i++) {
252 if (routes->gsi[i] >= 0) {
253 kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
260 * kvm_flic_save - Save pending floating interrupts
261 * @f: QEMUFile containing migration state
262 * @opaque: pointer to flic device state
264 * Note: Pass buf and len to kernel. Start with one page and
265 * increase until buffer is sufficient or maxium size is
268 static void kvm_flic_save(QEMUFile *f, void *opaque)
270 KVMS390FLICState *flic = opaque;
271 int len = FLIC_SAVE_INITIAL_SIZE;
275 flic_disable_wait_pfault((struct KVMS390FLICState *) opaque);
277 buf = g_try_malloc0(len);
279 /* Storing FLIC_FAILED into the count field here will cause the
280 * target system to fail when attempting to load irqs from the
282 error_report("flic: couldn't allocate memory");
283 qemu_put_be64(f, FLIC_FAILED);
287 count = __get_all_irqs(flic, &buf, len);
289 error_report("flic: couldn't retrieve irqs from kernel, rc %d",
291 /* Storing FLIC_FAILED into the count field here will cause the
292 * target system to fail when attempting to load irqs from the
294 qemu_put_be64(f, FLIC_FAILED);
296 qemu_put_be64(f, count);
297 qemu_put_buffer(f, (uint8_t *) buf,
298 count * sizeof(struct kvm_s390_irq));
304 * kvm_flic_load - Load pending floating interrupts
305 * @f: QEMUFile containing migration state
306 * @opaque: pointer to flic device state
307 * @version_id: version id for migration
309 * Returns: value of flic_enqueue_irqs, -EINVAL on error
310 * Note: Do nothing when no interrupts where stored
313 static int kvm_flic_load(QEMUFile *f, void *opaque, int version_id)
320 if (version_id != FLIC_SAVEVM_VERSION) {
325 flic_enable_pfault((struct KVMS390FLICState *) opaque);
327 count = qemu_get_be64(f);
328 len = count * sizeof(struct kvm_s390_irq);
329 if (count == FLIC_FAILED) {
337 buf = g_try_malloc0(len);
343 if (qemu_get_buffer(f, (uint8_t *) buf, len) != len) {
347 r = flic_enqueue_irqs(buf, len, (struct KVMS390FLICState *) opaque);
355 static void kvm_s390_flic_realize(DeviceState *dev, Error **errp)
357 KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
358 struct kvm_create_device cd = {0};
362 if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
363 trace_flic_no_device_api(errno);
367 cd.type = KVM_DEV_TYPE_FLIC;
368 ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd);
370 trace_flic_create_device(errno);
373 flic_state->fd = cd.fd;
375 /* Register savevm handler for floating interrupts */
376 register_savevm(NULL, "s390-flic", 0, 1, kvm_flic_save,
377 kvm_flic_load, (void *) flic_state);
380 static void kvm_s390_flic_unrealize(DeviceState *dev, Error **errp)
382 KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
384 unregister_savevm(DEVICE(flic_state), "s390-flic", flic_state);
387 static void kvm_s390_flic_reset(DeviceState *dev)
389 KVMS390FLICState *flic = KVM_S390_FLIC(dev);
390 struct kvm_device_attr attr = {
391 .group = KVM_DEV_FLIC_CLEAR_IRQS,
395 if (flic->fd == -1) {
399 flic_disable_wait_pfault(flic);
401 rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
403 trace_flic_reset_failed(errno);
406 flic_enable_pfault(flic);
409 static void kvm_s390_flic_class_init(ObjectClass *oc, void *data)
411 DeviceClass *dc = DEVICE_CLASS(oc);
412 S390FLICStateClass *fsc = S390_FLIC_COMMON_CLASS(oc);
414 dc->realize = kvm_s390_flic_realize;
415 dc->unrealize = kvm_s390_flic_unrealize;
416 dc->reset = kvm_s390_flic_reset;
417 fsc->register_io_adapter = kvm_s390_register_io_adapter;
418 fsc->io_adapter_map = kvm_s390_io_adapter_map;
419 fsc->add_adapter_routes = kvm_s390_add_adapter_routes;
420 fsc->release_adapter_routes = kvm_s390_release_adapter_routes;
423 static const TypeInfo kvm_s390_flic_info = {
424 .name = TYPE_KVM_S390_FLIC,
425 .parent = TYPE_S390_FLIC_COMMON,
426 .instance_size = sizeof(KVMS390FLICState),
427 .class_init = kvm_s390_flic_class_init,
430 static void kvm_s390_flic_register_types(void)
432 type_register_static(&kvm_s390_flic_info);
435 type_init(kvm_s390_flic_register_types)