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