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"
15 #include "kvm_s390x.h"
16 #include <sys/ioctl.h>
17 #include "qemu/error-report.h"
18 #include "qemu/module.h"
19 #include "qapi/error.h"
20 #include "hw/sysbus.h"
21 #include "sysemu/kvm.h"
22 #include "hw/s390x/s390_flic.h"
23 #include "hw/s390x/adapter.h"
24 #include "hw/s390x/css.h"
25 #include "migration/qemu-file-types.h"
28 #define FLIC_SAVE_INITIAL_SIZE getpagesize()
29 #define FLIC_FAILED (-1UL)
30 #define FLIC_SAVEVM_VERSION 1
32 typedef struct KVMS390FLICState
{
33 S390FLICState parent_obj
;
36 bool clear_io_supported
;
39 static KVMS390FLICState
*s390_get_kvm_flic(S390FLICState
*fs
)
41 static KVMS390FLICState
*flic
;
44 /* we only have one flic device, so this is fine to cache */
45 flic
= KVM_S390_FLIC(fs
);
51 * flic_get_all_irqs - store all pending irqs in buffer
52 * @buf: pointer to buffer which is passed to kernel
53 * @len: length of buffer
54 * @flic: pointer to flic device state
56 * Returns: -ENOMEM if buffer is too small,
57 * -EINVAL if attr.group is invalid,
58 * -EFAULT if copying to userspace failed,
59 * on success return number of stored interrupts
61 static int flic_get_all_irqs(KVMS390FLICState
*flic
,
64 struct kvm_device_attr attr
= {
65 .group
= KVM_DEV_FLIC_GET_ALL_IRQS
,
66 .addr
= (uint64_t) buf
,
71 rc
= ioctl(flic
->fd
, KVM_GET_DEVICE_ATTR
, &attr
);
73 return rc
== -1 ? -errno
: rc
;
76 static void flic_enable_pfault(KVMS390FLICState
*flic
)
78 struct kvm_device_attr attr
= {
79 .group
= KVM_DEV_FLIC_APF_ENABLE
,
83 rc
= ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
);
86 fprintf(stderr
, "flic: couldn't enable pfault\n");
90 static void flic_disable_wait_pfault(KVMS390FLICState
*flic
)
92 struct kvm_device_attr attr
= {
93 .group
= KVM_DEV_FLIC_APF_DISABLE_WAIT
,
97 rc
= ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
);
100 fprintf(stderr
, "flic: couldn't disable pfault\n");
104 /** flic_enqueue_irqs - returns 0 on success
105 * @buf: pointer to buffer which is passed to kernel
106 * @len: length of buffer
107 * @flic: pointer to flic device state
109 * Returns: -EINVAL if attr.group is unknown
111 static int flic_enqueue_irqs(void *buf
, uint64_t len
,
112 KVMS390FLICState
*flic
)
115 struct kvm_device_attr attr
= {
116 .group
= KVM_DEV_FLIC_ENQUEUE
,
117 .addr
= (uint64_t) buf
,
121 rc
= ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
);
123 return rc
? -errno
: 0;
126 static void kvm_s390_inject_flic(S390FLICState
*fs
, struct kvm_s390_irq
*irq
)
128 static bool use_flic
= true;
132 r
= flic_enqueue_irqs(irq
, sizeof(*irq
), s390_get_kvm_flic(fs
));
140 /* fallback to legacy KVM IOCTL in case FLIC fails */
141 kvm_s390_floating_interrupt_legacy(irq
);
144 static void kvm_s390_inject_service(S390FLICState
*fs
, uint32_t parm
)
146 struct kvm_s390_irq irq
= {
147 .type
= KVM_S390_INT_SERVICE
,
148 .u
.ext
.ext_params
= parm
,
151 kvm_s390_inject_flic(fs
, &irq
);
154 static void kvm_s390_inject_io(S390FLICState
*fs
, uint16_t subchannel_id
,
155 uint16_t subchannel_nr
, uint32_t io_int_parm
,
156 uint32_t io_int_word
)
158 struct kvm_s390_irq irq
= {
159 .u
.io
.subchannel_id
= subchannel_id
,
160 .u
.io
.subchannel_nr
= subchannel_nr
,
161 .u
.io
.io_int_parm
= io_int_parm
,
162 .u
.io
.io_int_word
= io_int_word
,
165 if (io_int_word
& IO_INT_WORD_AI
) {
166 irq
.type
= KVM_S390_INT_IO(1, 0, 0, 0);
168 irq
.type
= KVM_S390_INT_IO(0, (subchannel_id
& 0xff00) >> 8,
169 (subchannel_id
& 0x0006),
172 kvm_s390_inject_flic(fs
, &irq
);
175 static void kvm_s390_inject_crw_mchk(S390FLICState
*fs
)
177 struct kvm_s390_irq irq
= {
178 .type
= KVM_S390_MCHK
,
179 .u
.mchk
.cr14
= CR14_CHANNEL_REPORT_SC
,
180 .u
.mchk
.mcic
= s390_build_validity_mcic() | MCIC_SC_CP
,
183 kvm_s390_inject_flic(fs
, &irq
);
186 static int kvm_s390_clear_io_flic(S390FLICState
*fs
, uint16_t subchannel_id
,
187 uint16_t subchannel_nr
)
189 KVMS390FLICState
*flic
= s390_get_kvm_flic(fs
);
191 uint32_t sid
= subchannel_id
<< 16 | subchannel_nr
;
192 struct kvm_device_attr attr
= {
193 .group
= KVM_DEV_FLIC_CLEAR_IO_IRQ
,
194 .addr
= (uint64_t) &sid
,
197 if (unlikely(!flic
->clear_io_supported
)) {
200 rc
= ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
);
201 return rc
? -errno
: 0;
204 static int kvm_s390_modify_ais_mode(S390FLICState
*fs
, uint8_t isc
,
207 KVMS390FLICState
*flic
= s390_get_kvm_flic(fs
);
208 struct kvm_s390_ais_req req
= {
212 struct kvm_device_attr attr
= {
213 .group
= KVM_DEV_FLIC_AISM
,
214 .addr
= (uint64_t)&req
,
217 if (!fs
->ais_supported
) {
221 return ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
) ? -errno
: 0;
224 static int kvm_s390_inject_airq(S390FLICState
*fs
, uint8_t type
,
225 uint8_t isc
, uint8_t flags
)
227 KVMS390FLICState
*flic
= s390_get_kvm_flic(fs
);
228 uint32_t id
= css_get_adapter_id(type
, isc
);
229 struct kvm_device_attr attr
= {
230 .group
= KVM_DEV_FLIC_AIRQ_INJECT
,
234 if (!fs
->ais_supported
) {
238 return ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
) ? -errno
: 0;
242 * __get_all_irqs - store all pending irqs in buffer
243 * @flic: pointer to flic device state
244 * @buf: pointer to pointer to a buffer
245 * @len: length of buffer
247 * Returns: return value of flic_get_all_irqs
248 * Note: Retry and increase buffer size until flic_get_all_irqs
249 * either returns a value >= 0 or a negative error code.
250 * -ENOMEM is an exception, which means the buffer is too small
251 * and we should try again. Other negative error codes can be
252 * -EFAULT and -EINVAL which we ignore at this point
254 static int __get_all_irqs(KVMS390FLICState
*flic
,
260 /* returns -ENOMEM if buffer is too small and number
261 * of queued interrupts on success */
262 r
= flic_get_all_irqs(flic
, *buf
, len
);
267 *buf
= g_try_realloc(*buf
, len
);
271 } while (r
== -ENOMEM
&& len
<= KVM_S390_FLIC_MAX_BUFFER
);
276 static int kvm_s390_register_io_adapter(S390FLICState
*fs
, uint32_t id
,
277 uint8_t isc
, bool swap
,
278 bool is_maskable
, uint8_t flags
)
280 struct kvm_s390_io_adapter adapter
= {
283 .maskable
= is_maskable
,
287 KVMS390FLICState
*flic
= KVM_S390_FLIC(fs
);
289 struct kvm_device_attr attr
= {
290 .group
= KVM_DEV_FLIC_ADAPTER_REGISTER
,
291 .addr
= (uint64_t)&adapter
,
294 if (!kvm_gsi_routing_enabled()) {
299 r
= ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
);
301 return r
? -errno
: 0;
304 static int kvm_s390_io_adapter_map(S390FLICState
*fs
, uint32_t id
,
305 uint64_t map_addr
, bool do_map
)
307 struct kvm_s390_io_adapter_req req
= {
309 .type
= do_map
? KVM_S390_IO_ADAPTER_MAP
: KVM_S390_IO_ADAPTER_UNMAP
,
312 struct kvm_device_attr attr
= {
313 .group
= KVM_DEV_FLIC_ADAPTER_MODIFY
,
314 .addr
= (uint64_t)&req
,
316 KVMS390FLICState
*flic
= s390_get_kvm_flic(fs
);
319 if (!kvm_gsi_routing_enabled()) {
324 r
= ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
);
325 return r
? -errno
: 0;
328 static int kvm_s390_add_adapter_routes(S390FLICState
*fs
,
329 AdapterRoutes
*routes
)
332 uint64_t ind_offset
= routes
->adapter
.ind_offset
;
334 for (i
= 0; i
< routes
->num_routes
; i
++) {
335 ret
= kvm_irqchip_add_adapter_route(kvm_state
, &routes
->adapter
);
339 routes
->gsi
[i
] = ret
;
340 routes
->adapter
.ind_offset
++;
342 kvm_irqchip_commit_routes(kvm_state
);
344 /* Restore passed-in structure to original state. */
345 routes
->adapter
.ind_offset
= ind_offset
;
349 kvm_irqchip_release_virq(kvm_state
, routes
->gsi
[i
]);
352 routes
->adapter
.ind_offset
= ind_offset
;
356 static void kvm_s390_release_adapter_routes(S390FLICState
*fs
,
357 AdapterRoutes
*routes
)
361 for (i
= 0; i
< routes
->num_routes
; i
++) {
362 if (routes
->gsi
[i
] >= 0) {
363 kvm_irqchip_release_virq(kvm_state
, routes
->gsi
[i
]);
370 * kvm_flic_save - Save pending floating interrupts
371 * @f: QEMUFile containing migration state
372 * @opaque: pointer to flic device state
375 * Note: Pass buf and len to kernel. Start with one page and
376 * increase until buffer is sufficient or maxium size is
379 static int kvm_flic_save(QEMUFile
*f
, void *opaque
, size_t size
,
380 const VMStateField
*field
, QJSON
*vmdesc
)
382 KVMS390FLICState
*flic
= opaque
;
383 int len
= FLIC_SAVE_INITIAL_SIZE
;
388 flic_disable_wait_pfault((struct KVMS390FLICState
*) opaque
);
390 buf
= g_try_malloc0(len
);
392 /* Storing FLIC_FAILED into the count field here will cause the
393 * target system to fail when attempting to load irqs from the
395 error_report("flic: couldn't allocate memory");
396 qemu_put_be64(f
, FLIC_FAILED
);
400 count
= __get_all_irqs(flic
, &buf
, len
);
402 error_report("flic: couldn't retrieve irqs from kernel, rc %d",
404 /* Storing FLIC_FAILED into the count field here will cause the
405 * target system to fail when attempting to load irqs from the
407 qemu_put_be64(f
, FLIC_FAILED
);
410 qemu_put_be64(f
, count
);
411 qemu_put_buffer(f
, (uint8_t *) buf
,
412 count
* sizeof(struct kvm_s390_irq
));
420 * kvm_flic_load - Load pending floating interrupts
421 * @f: QEMUFile containing migration state
422 * @opaque: pointer to flic device state
425 * Returns: value of flic_enqueue_irqs, -EINVAL on error
426 * Note: Do nothing when no interrupts where stored
429 static int kvm_flic_load(QEMUFile
*f
, void *opaque
, size_t size
,
430 const VMStateField
*field
)
437 flic_enable_pfault((struct KVMS390FLICState
*) opaque
);
439 count
= qemu_get_be64(f
);
440 len
= count
* sizeof(struct kvm_s390_irq
);
441 if (count
== FLIC_FAILED
) {
449 buf
= g_try_malloc0(len
);
455 if (qemu_get_buffer(f
, (uint8_t *) buf
, len
) != len
) {
459 r
= flic_enqueue_irqs(buf
, len
, (struct KVMS390FLICState
*) opaque
);
467 typedef struct KVMS390FLICStateMigTmp
{
468 KVMS390FLICState
*parent
;
471 } KVMS390FLICStateMigTmp
;
473 static int kvm_flic_ais_pre_save(void *opaque
)
475 KVMS390FLICStateMigTmp
*tmp
= opaque
;
476 KVMS390FLICState
*flic
= tmp
->parent
;
477 struct kvm_s390_ais_all ais
;
478 struct kvm_device_attr attr
= {
479 .group
= KVM_DEV_FLIC_AISM_ALL
,
480 .addr
= (uint64_t)&ais
,
484 if (ioctl(flic
->fd
, KVM_GET_DEVICE_ATTR
, &attr
)) {
485 error_report("Failed to retrieve kvm flic ais states");
489 tmp
->simm
= ais
.simm
;
490 tmp
->nimm
= ais
.nimm
;
495 static int kvm_flic_ais_post_load(void *opaque
, int version_id
)
497 KVMS390FLICStateMigTmp
*tmp
= opaque
;
498 KVMS390FLICState
*flic
= tmp
->parent
;
499 struct kvm_s390_ais_all ais
= {
503 struct kvm_device_attr attr
= {
504 .group
= KVM_DEV_FLIC_AISM_ALL
,
505 .addr
= (uint64_t)&ais
,
508 /* This can happen when the user mis-configures its guests in an
509 * incompatible fashion or without a CPU model. For example using
510 * qemu with -cpu host (which is not migration safe) and do a
511 * migration from a host that has AIS to a host that has no AIS.
512 * In that case the target system will reject the migration here.
514 if (!ais_needed(flic
)) {
518 return ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
) ? -errno
: 0;
521 static const VMStateDescription kvm_s390_flic_ais_tmp
= {
522 .name
= "s390-flic-ais-tmp",
523 .pre_save
= kvm_flic_ais_pre_save
,
524 .post_load
= kvm_flic_ais_post_load
,
525 .fields
= (VMStateField
[]) {
526 VMSTATE_UINT8(simm
, KVMS390FLICStateMigTmp
),
527 VMSTATE_UINT8(nimm
, KVMS390FLICStateMigTmp
),
528 VMSTATE_END_OF_LIST()
532 static const VMStateDescription kvm_s390_flic_vmstate_ais
= {
533 .name
= "s390-flic/ais",
535 .minimum_version_id
= 1,
536 .needed
= ais_needed
,
537 .fields
= (VMStateField
[]) {
538 VMSTATE_WITH_TMP(KVMS390FLICState
, KVMS390FLICStateMigTmp
,
539 kvm_s390_flic_ais_tmp
),
540 VMSTATE_END_OF_LIST()
544 static const VMStateDescription kvm_s390_flic_vmstate
= {
545 /* should have been like kvm-s390-flic,
546 * can't change without breaking compat */
548 .version_id
= FLIC_SAVEVM_VERSION
,
549 .minimum_version_id
= FLIC_SAVEVM_VERSION
,
550 .fields
= (VMStateField
[]) {
553 .info
= &(const VMStateInfo
) {
555 .get
= kvm_flic_load
,
556 .put
= kvm_flic_save
,
560 VMSTATE_END_OF_LIST()
562 .subsections
= (const VMStateDescription
* []) {
563 &kvm_s390_flic_vmstate_ais
,
568 typedef struct KVMS390FLICStateClass
{
569 S390FLICStateClass parent_class
;
570 DeviceRealize parent_realize
;
571 } KVMS390FLICStateClass
;
573 #define KVM_S390_FLIC_GET_CLASS(obj) \
574 OBJECT_GET_CLASS(KVMS390FLICStateClass, (obj), TYPE_KVM_S390_FLIC)
576 #define KVM_S390_FLIC_CLASS(klass) \
577 OBJECT_CLASS_CHECK(KVMS390FLICStateClass, (klass), TYPE_KVM_S390_FLIC)
579 static void kvm_s390_flic_realize(DeviceState
*dev
, Error
**errp
)
581 KVMS390FLICState
*flic_state
= KVM_S390_FLIC(dev
);
582 struct kvm_create_device cd
= {0};
583 struct kvm_device_attr test_attr
= {0};
585 Error
*errp_local
= NULL
;
587 KVM_S390_FLIC_GET_CLASS(dev
)->parent_realize(dev
, &errp_local
);
592 if (!kvm_check_extension(kvm_state
, KVM_CAP_DEVICE_CTRL
)) {
593 error_setg_errno(&errp_local
, errno
, "KVM is missing capability"
594 " KVM_CAP_DEVICE_CTRL");
595 trace_flic_no_device_api(errno
);
599 cd
.type
= KVM_DEV_TYPE_FLIC
;
600 ret
= kvm_vm_ioctl(kvm_state
, KVM_CREATE_DEVICE
, &cd
);
602 error_setg_errno(&errp_local
, errno
, "Creating the KVM device failed");
603 trace_flic_create_device(errno
);
606 flic_state
->fd
= cd
.fd
;
608 /* Check clear_io_irq support */
609 test_attr
.group
= KVM_DEV_FLIC_CLEAR_IO_IRQ
;
610 flic_state
->clear_io_supported
= !ioctl(flic_state
->fd
,
611 KVM_HAS_DEVICE_ATTR
, test_attr
);
614 error_propagate(errp
, errp_local
);
617 static void kvm_s390_flic_reset(DeviceState
*dev
)
619 KVMS390FLICState
*flic
= KVM_S390_FLIC(dev
);
620 S390FLICState
*fs
= S390_FLIC_COMMON(dev
);
621 struct kvm_device_attr attr
= {
622 .group
= KVM_DEV_FLIC_CLEAR_IRQS
,
627 if (flic
->fd
== -1) {
631 flic_disable_wait_pfault(flic
);
633 if (fs
->ais_supported
) {
634 for (isc
= 0; isc
<= MAX_ISC
; isc
++) {
635 rc
= kvm_s390_modify_ais_mode(fs
, isc
, SIC_IRQ_MODE_ALL
);
637 error_report("Failed to reset ais mode for isc %d: %s",
643 rc
= ioctl(flic
->fd
, KVM_SET_DEVICE_ATTR
, &attr
);
645 trace_flic_reset_failed(errno
);
648 flic_enable_pfault(flic
);
651 static void kvm_s390_flic_class_init(ObjectClass
*oc
, void *data
)
653 DeviceClass
*dc
= DEVICE_CLASS(oc
);
654 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_CLASS(oc
);
656 KVM_S390_FLIC_CLASS(oc
)->parent_realize
= dc
->realize
;
657 dc
->realize
= kvm_s390_flic_realize
;
658 dc
->vmsd
= &kvm_s390_flic_vmstate
;
659 dc
->reset
= kvm_s390_flic_reset
;
660 fsc
->register_io_adapter
= kvm_s390_register_io_adapter
;
661 fsc
->io_adapter_map
= kvm_s390_io_adapter_map
;
662 fsc
->add_adapter_routes
= kvm_s390_add_adapter_routes
;
663 fsc
->release_adapter_routes
= kvm_s390_release_adapter_routes
;
664 fsc
->clear_io_irq
= kvm_s390_clear_io_flic
;
665 fsc
->modify_ais_mode
= kvm_s390_modify_ais_mode
;
666 fsc
->inject_airq
= kvm_s390_inject_airq
;
667 fsc
->inject_service
= kvm_s390_inject_service
;
668 fsc
->inject_io
= kvm_s390_inject_io
;
669 fsc
->inject_crw_mchk
= kvm_s390_inject_crw_mchk
;
672 static const TypeInfo kvm_s390_flic_info
= {
673 .name
= TYPE_KVM_S390_FLIC
,
674 .parent
= TYPE_S390_FLIC_COMMON
,
675 .instance_size
= sizeof(KVMS390FLICState
),
676 .class_size
= sizeof(KVMS390FLICStateClass
),
677 .class_init
= kvm_s390_flic_class_init
,
680 static void kvm_s390_flic_register_types(void)
682 type_register_static(&kvm_s390_flic_info
);
685 type_init(kvm_s390_flic_register_types
)