pc: ACPI BIOS: make GPE.3 handle memory hotplug event on PIIX and Q35 machines
[qemu/ar7.git] / target-s390x / kvm.c
bloba1a4cc2cab8c0ae7e7ab4a50781c472dec3c9ca5
1 /*
2 * QEMU S390x KVM implementation
4 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
5 * Copyright IBM Corp. 2012
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * Contributions after 2012-10-29 are licensed under the terms of the
18 * GNU GPL, version 2 or (at your option) any later version.
20 * You should have received a copy of the GNU (Lesser) General Public
21 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
24 #include <sys/types.h>
25 #include <sys/ioctl.h>
26 #include <sys/mman.h>
28 #include <linux/kvm.h>
29 #include <asm/ptrace.h>
31 #include "qemu-common.h"
32 #include "qemu/timer.h"
33 #include "sysemu/sysemu.h"
34 #include "sysemu/kvm.h"
35 #include "hw/hw.h"
36 #include "cpu.h"
37 #include "sysemu/device_tree.h"
38 #include "qapi/qmp/qjson.h"
39 #include "monitor/monitor.h"
40 #include "exec/gdbstub.h"
41 #include "trace.h"
43 /* #define DEBUG_KVM */
45 #ifdef DEBUG_KVM
46 #define DPRINTF(fmt, ...) \
47 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
48 #else
49 #define DPRINTF(fmt, ...) \
50 do { } while (0)
51 #endif
53 #define IPA0_DIAG 0x8300
54 #define IPA0_SIGP 0xae00
55 #define IPA0_B2 0xb200
56 #define IPA0_B9 0xb900
57 #define IPA0_EB 0xeb00
59 #define PRIV_B2_SCLP_CALL 0x20
60 #define PRIV_B2_CSCH 0x30
61 #define PRIV_B2_HSCH 0x31
62 #define PRIV_B2_MSCH 0x32
63 #define PRIV_B2_SSCH 0x33
64 #define PRIV_B2_STSCH 0x34
65 #define PRIV_B2_TSCH 0x35
66 #define PRIV_B2_TPI 0x36
67 #define PRIV_B2_SAL 0x37
68 #define PRIV_B2_RSCH 0x38
69 #define PRIV_B2_STCRW 0x39
70 #define PRIV_B2_STCPS 0x3a
71 #define PRIV_B2_RCHP 0x3b
72 #define PRIV_B2_SCHM 0x3c
73 #define PRIV_B2_CHSC 0x5f
74 #define PRIV_B2_SIGA 0x74
75 #define PRIV_B2_XSCH 0x76
77 #define PRIV_EB_SQBS 0x8a
79 #define PRIV_B9_EQBS 0x9c
81 #define DIAG_IPL 0x308
82 #define DIAG_KVM_HYPERCALL 0x500
83 #define DIAG_KVM_BREAKPOINT 0x501
85 #define ICPT_INSTRUCTION 0x04
86 #define ICPT_PROGRAM 0x08
87 #define ICPT_EXT_INT 0x14
88 #define ICPT_WAITPSW 0x1c
89 #define ICPT_SOFT_INTERCEPT 0x24
90 #define ICPT_CPU_STOP 0x28
91 #define ICPT_IO 0x40
93 static CPUWatchpoint hw_watchpoint;
95 * We don't use a list because this structure is also used to transmit the
96 * hardware breakpoints to the kernel.
98 static struct kvm_hw_breakpoint *hw_breakpoints;
99 static int nb_hw_breakpoints;
101 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
102 KVM_CAP_LAST_INFO
105 static int cap_sync_regs;
106 static int cap_async_pf;
108 static void *legacy_s390_alloc(size_t size);
110 static int kvm_s390_check_clear_cmma(KVMState *s)
112 struct kvm_device_attr attr = {
113 .group = KVM_S390_VM_MEM_CTRL,
114 .attr = KVM_S390_VM_MEM_CLR_CMMA,
117 return kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attr);
120 static int kvm_s390_check_enable_cmma(KVMState *s)
122 struct kvm_device_attr attr = {
123 .group = KVM_S390_VM_MEM_CTRL,
124 .attr = KVM_S390_VM_MEM_ENABLE_CMMA,
127 return kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attr);
130 void kvm_s390_clear_cmma_callback(void *opaque)
132 int rc;
133 KVMState *s = opaque;
134 struct kvm_device_attr attr = {
135 .group = KVM_S390_VM_MEM_CTRL,
136 .attr = KVM_S390_VM_MEM_CLR_CMMA,
139 rc = kvm_vm_ioctl(s, KVM_SET_DEVICE_ATTR, &attr);
140 trace_kvm_clear_cmma(rc);
143 static void kvm_s390_enable_cmma(KVMState *s)
145 int rc;
146 struct kvm_device_attr attr = {
147 .group = KVM_S390_VM_MEM_CTRL,
148 .attr = KVM_S390_VM_MEM_ENABLE_CMMA,
151 if (kvm_s390_check_enable_cmma(s) || kvm_s390_check_clear_cmma(s)) {
152 return;
155 rc = kvm_vm_ioctl(s, KVM_SET_DEVICE_ATTR, &attr);
156 if (!rc) {
157 qemu_register_reset(kvm_s390_clear_cmma_callback, s);
159 trace_kvm_enable_cmma(rc);
162 int kvm_arch_init(KVMState *s)
164 cap_sync_regs = kvm_check_extension(s, KVM_CAP_SYNC_REGS);
165 cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF);
167 if (kvm_check_extension(s, KVM_CAP_VM_ATTRIBUTES)) {
168 kvm_s390_enable_cmma(s);
171 if (!kvm_check_extension(s, KVM_CAP_S390_GMAP)
172 || !kvm_check_extension(s, KVM_CAP_S390_COW)) {
173 phys_mem_set_alloc(legacy_s390_alloc);
175 return 0;
178 unsigned long kvm_arch_vcpu_id(CPUState *cpu)
180 return cpu->cpu_index;
183 int kvm_arch_init_vcpu(CPUState *cpu)
185 /* nothing todo yet */
186 return 0;
189 void kvm_s390_reset_vcpu(S390CPU *cpu)
191 CPUState *cs = CPU(cpu);
193 /* The initial reset call is needed here to reset in-kernel
194 * vcpu data that we can't access directly from QEMU
195 * (i.e. with older kernels which don't support sync_regs/ONE_REG).
196 * Before this ioctl cpu_synchronize_state() is called in common kvm
197 * code (kvm-all) */
198 if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL)) {
199 perror("Can't reset vcpu\n");
203 int kvm_arch_put_registers(CPUState *cs, int level)
205 S390CPU *cpu = S390_CPU(cs);
206 CPUS390XState *env = &cpu->env;
207 struct kvm_sregs sregs;
208 struct kvm_regs regs;
209 int r;
210 int i;
212 /* always save the PSW and the GPRS*/
213 cs->kvm_run->psw_addr = env->psw.addr;
214 cs->kvm_run->psw_mask = env->psw.mask;
216 if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_GPRS) {
217 for (i = 0; i < 16; i++) {
218 cs->kvm_run->s.regs.gprs[i] = env->regs[i];
219 cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_GPRS;
221 } else {
222 for (i = 0; i < 16; i++) {
223 regs.gprs[i] = env->regs[i];
225 r = kvm_vcpu_ioctl(cs, KVM_SET_REGS, &regs);
226 if (r < 0) {
227 return r;
231 /* Do we need to save more than that? */
232 if (level == KVM_PUT_RUNTIME_STATE) {
233 return 0;
237 * These ONE_REGS are not protected by a capability. As they are only
238 * necessary for migration we just trace a possible error, but don't
239 * return with an error return code.
241 kvm_set_one_reg(cs, KVM_REG_S390_CPU_TIMER, &env->cputm);
242 kvm_set_one_reg(cs, KVM_REG_S390_CLOCK_COMP, &env->ckc);
243 kvm_set_one_reg(cs, KVM_REG_S390_TODPR, &env->todpr);
244 kvm_set_one_reg(cs, KVM_REG_S390_GBEA, &env->gbea);
245 kvm_set_one_reg(cs, KVM_REG_S390_PP, &env->pp);
247 if (cap_async_pf) {
248 r = kvm_set_one_reg(cs, KVM_REG_S390_PFTOKEN, &env->pfault_token);
249 if (r < 0) {
250 return r;
252 r = kvm_set_one_reg(cs, KVM_REG_S390_PFCOMPARE, &env->pfault_compare);
253 if (r < 0) {
254 return r;
256 r = kvm_set_one_reg(cs, KVM_REG_S390_PFSELECT, &env->pfault_select);
257 if (r < 0) {
258 return r;
262 if (cap_sync_regs &&
263 cs->kvm_run->kvm_valid_regs & KVM_SYNC_ACRS &&
264 cs->kvm_run->kvm_valid_regs & KVM_SYNC_CRS) {
265 for (i = 0; i < 16; i++) {
266 cs->kvm_run->s.regs.acrs[i] = env->aregs[i];
267 cs->kvm_run->s.regs.crs[i] = env->cregs[i];
269 cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_ACRS;
270 cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_CRS;
271 } else {
272 for (i = 0; i < 16; i++) {
273 sregs.acrs[i] = env->aregs[i];
274 sregs.crs[i] = env->cregs[i];
276 r = kvm_vcpu_ioctl(cs, KVM_SET_SREGS, &sregs);
277 if (r < 0) {
278 return r;
282 /* Finally the prefix */
283 if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_PREFIX) {
284 cs->kvm_run->s.regs.prefix = env->psa;
285 cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_PREFIX;
286 } else {
287 /* prefix is only supported via sync regs */
289 return 0;
292 int kvm_arch_get_registers(CPUState *cs)
294 S390CPU *cpu = S390_CPU(cs);
295 CPUS390XState *env = &cpu->env;
296 struct kvm_sregs sregs;
297 struct kvm_regs regs;
298 int i, r;
300 /* get the PSW */
301 env->psw.addr = cs->kvm_run->psw_addr;
302 env->psw.mask = cs->kvm_run->psw_mask;
304 /* the GPRS */
305 if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_GPRS) {
306 for (i = 0; i < 16; i++) {
307 env->regs[i] = cs->kvm_run->s.regs.gprs[i];
309 } else {
310 r = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
311 if (r < 0) {
312 return r;
314 for (i = 0; i < 16; i++) {
315 env->regs[i] = regs.gprs[i];
319 /* The ACRS and CRS */
320 if (cap_sync_regs &&
321 cs->kvm_run->kvm_valid_regs & KVM_SYNC_ACRS &&
322 cs->kvm_run->kvm_valid_regs & KVM_SYNC_CRS) {
323 for (i = 0; i < 16; i++) {
324 env->aregs[i] = cs->kvm_run->s.regs.acrs[i];
325 env->cregs[i] = cs->kvm_run->s.regs.crs[i];
327 } else {
328 r = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
329 if (r < 0) {
330 return r;
332 for (i = 0; i < 16; i++) {
333 env->aregs[i] = sregs.acrs[i];
334 env->cregs[i] = sregs.crs[i];
338 /* The prefix */
339 if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_PREFIX) {
340 env->psa = cs->kvm_run->s.regs.prefix;
344 * These ONE_REGS are not protected by a capability. As they are only
345 * necessary for migration we just trace a possible error, but don't
346 * return with an error return code.
348 kvm_get_one_reg(cs, KVM_REG_S390_CPU_TIMER, &env->cputm);
349 kvm_get_one_reg(cs, KVM_REG_S390_CLOCK_COMP, &env->ckc);
350 kvm_get_one_reg(cs, KVM_REG_S390_TODPR, &env->todpr);
351 kvm_get_one_reg(cs, KVM_REG_S390_GBEA, &env->gbea);
352 kvm_get_one_reg(cs, KVM_REG_S390_PP, &env->pp);
354 if (cap_async_pf) {
355 r = kvm_get_one_reg(cs, KVM_REG_S390_PFTOKEN, &env->pfault_token);
356 if (r < 0) {
357 return r;
359 r = kvm_get_one_reg(cs, KVM_REG_S390_PFCOMPARE, &env->pfault_compare);
360 if (r < 0) {
361 return r;
363 r = kvm_get_one_reg(cs, KVM_REG_S390_PFSELECT, &env->pfault_select);
364 if (r < 0) {
365 return r;
369 return 0;
373 * Legacy layout for s390:
374 * Older S390 KVM requires the topmost vma of the RAM to be
375 * smaller than an system defined value, which is at least 256GB.
376 * Larger systems have larger values. We put the guest between
377 * the end of data segment (system break) and this value. We
378 * use 32GB as a base to have enough room for the system break
379 * to grow. We also have to use MAP parameters that avoid
380 * read-only mapping of guest pages.
382 static void *legacy_s390_alloc(size_t size)
384 void *mem;
386 mem = mmap((void *) 0x800000000ULL, size,
387 PROT_EXEC|PROT_READ|PROT_WRITE,
388 MAP_SHARED | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
389 return mem == MAP_FAILED ? NULL : mem;
392 /* DIAG 501 is used for sw breakpoints */
393 static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
395 int kvm_arch_insert_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
398 if (cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn,
399 sizeof(diag_501), 0) ||
400 cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)diag_501,
401 sizeof(diag_501), 1)) {
402 return -EINVAL;
404 return 0;
407 int kvm_arch_remove_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
409 uint8_t t[sizeof(diag_501)];
411 if (cpu_memory_rw_debug(cs, bp->pc, t, sizeof(diag_501), 0)) {
412 return -EINVAL;
413 } else if (memcmp(t, diag_501, sizeof(diag_501))) {
414 return -EINVAL;
415 } else if (cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn,
416 sizeof(diag_501), 1)) {
417 return -EINVAL;
420 return 0;
423 static struct kvm_hw_breakpoint *find_hw_breakpoint(target_ulong addr,
424 int len, int type)
426 int n;
428 for (n = 0; n < nb_hw_breakpoints; n++) {
429 if (hw_breakpoints[n].addr == addr && hw_breakpoints[n].type == type &&
430 (hw_breakpoints[n].len == len || len == -1)) {
431 return &hw_breakpoints[n];
435 return NULL;
438 static int insert_hw_breakpoint(target_ulong addr, int len, int type)
440 int size;
442 if (find_hw_breakpoint(addr, len, type)) {
443 return -EEXIST;
446 size = (nb_hw_breakpoints + 1) * sizeof(struct kvm_hw_breakpoint);
448 if (!hw_breakpoints) {
449 nb_hw_breakpoints = 0;
450 hw_breakpoints = (struct kvm_hw_breakpoint *)g_try_malloc(size);
451 } else {
452 hw_breakpoints =
453 (struct kvm_hw_breakpoint *)g_try_realloc(hw_breakpoints, size);
456 if (!hw_breakpoints) {
457 nb_hw_breakpoints = 0;
458 return -ENOMEM;
461 hw_breakpoints[nb_hw_breakpoints].addr = addr;
462 hw_breakpoints[nb_hw_breakpoints].len = len;
463 hw_breakpoints[nb_hw_breakpoints].type = type;
465 nb_hw_breakpoints++;
467 return 0;
470 int kvm_arch_insert_hw_breakpoint(target_ulong addr,
471 target_ulong len, int type)
473 switch (type) {
474 case GDB_BREAKPOINT_HW:
475 type = KVM_HW_BP;
476 break;
477 case GDB_WATCHPOINT_WRITE:
478 if (len < 1) {
479 return -EINVAL;
481 type = KVM_HW_WP_WRITE;
482 break;
483 default:
484 return -ENOSYS;
486 return insert_hw_breakpoint(addr, len, type);
489 int kvm_arch_remove_hw_breakpoint(target_ulong addr,
490 target_ulong len, int type)
492 int size;
493 struct kvm_hw_breakpoint *bp = find_hw_breakpoint(addr, len, type);
495 if (bp == NULL) {
496 return -ENOENT;
499 nb_hw_breakpoints--;
500 if (nb_hw_breakpoints > 0) {
502 * In order to trim the array, move the last element to the position to
503 * be removed - if necessary.
505 if (bp != &hw_breakpoints[nb_hw_breakpoints]) {
506 *bp = hw_breakpoints[nb_hw_breakpoints];
508 size = nb_hw_breakpoints * sizeof(struct kvm_hw_breakpoint);
509 hw_breakpoints =
510 (struct kvm_hw_breakpoint *)g_realloc(hw_breakpoints, size);
511 } else {
512 g_free(hw_breakpoints);
513 hw_breakpoints = NULL;
516 return 0;
519 void kvm_arch_remove_all_hw_breakpoints(void)
521 nb_hw_breakpoints = 0;
522 g_free(hw_breakpoints);
523 hw_breakpoints = NULL;
526 void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg)
528 int i;
530 if (nb_hw_breakpoints > 0) {
531 dbg->arch.nr_hw_bp = nb_hw_breakpoints;
532 dbg->arch.hw_bp = hw_breakpoints;
534 for (i = 0; i < nb_hw_breakpoints; ++i) {
535 hw_breakpoints[i].phys_addr = s390_cpu_get_phys_addr_debug(cpu,
536 hw_breakpoints[i].addr);
538 dbg->control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_HW_BP;
539 } else {
540 dbg->arch.nr_hw_bp = 0;
541 dbg->arch.hw_bp = NULL;
545 void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
549 void kvm_arch_post_run(CPUState *cpu, struct kvm_run *run)
553 int kvm_arch_process_async_events(CPUState *cs)
555 return cs->halted;
558 static int s390_kvm_irq_to_interrupt(struct kvm_s390_irq *irq,
559 struct kvm_s390_interrupt *interrupt)
561 int r = 0;
563 interrupt->type = irq->type;
564 switch (irq->type) {
565 case KVM_S390_INT_VIRTIO:
566 interrupt->parm = irq->u.ext.ext_params;
567 /* fall through */
568 case KVM_S390_INT_PFAULT_INIT:
569 case KVM_S390_INT_PFAULT_DONE:
570 interrupt->parm64 = irq->u.ext.ext_params2;
571 break;
572 case KVM_S390_PROGRAM_INT:
573 interrupt->parm = irq->u.pgm.code;
574 break;
575 case KVM_S390_SIGP_SET_PREFIX:
576 interrupt->parm = irq->u.prefix.address;
577 break;
578 case KVM_S390_INT_SERVICE:
579 interrupt->parm = irq->u.ext.ext_params;
580 break;
581 case KVM_S390_MCHK:
582 interrupt->parm = irq->u.mchk.cr14;
583 interrupt->parm64 = irq->u.mchk.mcic;
584 break;
585 case KVM_S390_INT_EXTERNAL_CALL:
586 interrupt->parm = irq->u.extcall.code;
587 break;
588 case KVM_S390_INT_EMERGENCY:
589 interrupt->parm = irq->u.emerg.code;
590 break;
591 case KVM_S390_SIGP_STOP:
592 case KVM_S390_RESTART:
593 break; /* These types have no parameters */
594 case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX:
595 interrupt->parm = irq->u.io.subchannel_id << 16;
596 interrupt->parm |= irq->u.io.subchannel_nr;
597 interrupt->parm64 = (uint64_t)irq->u.io.io_int_parm << 32;
598 interrupt->parm64 |= irq->u.io.io_int_word;
599 break;
600 default:
601 r = -EINVAL;
602 break;
604 return r;
607 void kvm_s390_vcpu_interrupt(S390CPU *cpu, struct kvm_s390_irq *irq)
609 struct kvm_s390_interrupt kvmint = {};
610 CPUState *cs = CPU(cpu);
611 int r;
613 r = s390_kvm_irq_to_interrupt(irq, &kvmint);
614 if (r < 0) {
615 fprintf(stderr, "%s called with bogus interrupt\n", __func__);
616 exit(1);
619 r = kvm_vcpu_ioctl(cs, KVM_S390_INTERRUPT, &kvmint);
620 if (r < 0) {
621 fprintf(stderr, "KVM failed to inject interrupt\n");
622 exit(1);
626 static void __kvm_s390_floating_interrupt(struct kvm_s390_irq *irq)
628 struct kvm_s390_interrupt kvmint = {};
629 int r;
631 r = s390_kvm_irq_to_interrupt(irq, &kvmint);
632 if (r < 0) {
633 fprintf(stderr, "%s called with bogus interrupt\n", __func__);
634 exit(1);
637 r = kvm_vm_ioctl(kvm_state, KVM_S390_INTERRUPT, &kvmint);
638 if (r < 0) {
639 fprintf(stderr, "KVM failed to inject interrupt\n");
640 exit(1);
644 void kvm_s390_floating_interrupt(struct kvm_s390_irq *irq)
646 static bool use_flic = true;
647 int r;
649 if (use_flic) {
650 r = kvm_s390_inject_flic(irq);
651 if (r == -ENOSYS) {
652 use_flic = false;
654 if (!r) {
655 return;
658 __kvm_s390_floating_interrupt(irq);
661 void kvm_s390_virtio_irq(int config_change, uint64_t token)
663 struct kvm_s390_irq irq = {
664 .type = KVM_S390_INT_VIRTIO,
665 .u.ext.ext_params = config_change,
666 .u.ext.ext_params2 = token,
669 kvm_s390_floating_interrupt(&irq);
672 void kvm_s390_service_interrupt(uint32_t parm)
674 struct kvm_s390_irq irq = {
675 .type = KVM_S390_INT_SERVICE,
676 .u.ext.ext_params = parm,
679 kvm_s390_floating_interrupt(&irq);
682 static void enter_pgmcheck(S390CPU *cpu, uint16_t code)
684 struct kvm_s390_irq irq = {
685 .type = KVM_S390_PROGRAM_INT,
686 .u.pgm.code = code,
689 kvm_s390_vcpu_interrupt(cpu, &irq);
692 static int kvm_sclp_service_call(S390CPU *cpu, struct kvm_run *run,
693 uint16_t ipbh0)
695 CPUS390XState *env = &cpu->env;
696 uint64_t sccb;
697 uint32_t code;
698 int r = 0;
700 cpu_synchronize_state(CPU(cpu));
701 sccb = env->regs[ipbh0 & 0xf];
702 code = env->regs[(ipbh0 & 0xf0) >> 4];
704 r = sclp_service_call(env, sccb, code);
705 if (r < 0) {
706 enter_pgmcheck(cpu, -r);
707 } else {
708 setcc(cpu, r);
711 return 0;
714 static int handle_b2(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
716 CPUS390XState *env = &cpu->env;
717 int rc = 0;
718 uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
720 cpu_synchronize_state(CPU(cpu));
722 switch (ipa1) {
723 case PRIV_B2_XSCH:
724 ioinst_handle_xsch(cpu, env->regs[1]);
725 break;
726 case PRIV_B2_CSCH:
727 ioinst_handle_csch(cpu, env->regs[1]);
728 break;
729 case PRIV_B2_HSCH:
730 ioinst_handle_hsch(cpu, env->regs[1]);
731 break;
732 case PRIV_B2_MSCH:
733 ioinst_handle_msch(cpu, env->regs[1], run->s390_sieic.ipb);
734 break;
735 case PRIV_B2_SSCH:
736 ioinst_handle_ssch(cpu, env->regs[1], run->s390_sieic.ipb);
737 break;
738 case PRIV_B2_STCRW:
739 ioinst_handle_stcrw(cpu, run->s390_sieic.ipb);
740 break;
741 case PRIV_B2_STSCH:
742 ioinst_handle_stsch(cpu, env->regs[1], run->s390_sieic.ipb);
743 break;
744 case PRIV_B2_TSCH:
745 /* We should only get tsch via KVM_EXIT_S390_TSCH. */
746 fprintf(stderr, "Spurious tsch intercept\n");
747 break;
748 case PRIV_B2_CHSC:
749 ioinst_handle_chsc(cpu, run->s390_sieic.ipb);
750 break;
751 case PRIV_B2_TPI:
752 /* This should have been handled by kvm already. */
753 fprintf(stderr, "Spurious tpi intercept\n");
754 break;
755 case PRIV_B2_SCHM:
756 ioinst_handle_schm(cpu, env->regs[1], env->regs[2],
757 run->s390_sieic.ipb);
758 break;
759 case PRIV_B2_RSCH:
760 ioinst_handle_rsch(cpu, env->regs[1]);
761 break;
762 case PRIV_B2_RCHP:
763 ioinst_handle_rchp(cpu, env->regs[1]);
764 break;
765 case PRIV_B2_STCPS:
766 /* We do not provide this instruction, it is suppressed. */
767 break;
768 case PRIV_B2_SAL:
769 ioinst_handle_sal(cpu, env->regs[1]);
770 break;
771 case PRIV_B2_SIGA:
772 /* Not provided, set CC = 3 for subchannel not operational */
773 setcc(cpu, 3);
774 break;
775 case PRIV_B2_SCLP_CALL:
776 rc = kvm_sclp_service_call(cpu, run, ipbh0);
777 break;
778 default:
779 rc = -1;
780 DPRINTF("KVM: unhandled PRIV: 0xb2%x\n", ipa1);
781 break;
784 return rc;
787 static int handle_b9(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
789 int r = 0;
791 switch (ipa1) {
792 case PRIV_B9_EQBS:
793 /* just inject exception */
794 r = -1;
795 break;
796 default:
797 r = -1;
798 DPRINTF("KVM: unhandled PRIV: 0xb9%x\n", ipa1);
799 break;
802 return r;
805 static int handle_eb(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
807 int r = 0;
809 switch (ipa1) {
810 case PRIV_EB_SQBS:
811 /* just inject exception */
812 r = -1;
813 break;
814 default:
815 r = -1;
816 DPRINTF("KVM: unhandled PRIV: 0xeb%x\n", ipa1);
817 break;
820 return r;
823 static int handle_hypercall(S390CPU *cpu, struct kvm_run *run)
825 CPUS390XState *env = &cpu->env;
826 int ret;
828 cpu_synchronize_state(CPU(cpu));
829 ret = s390_virtio_hypercall(env);
830 if (ret == -EINVAL) {
831 enter_pgmcheck(cpu, PGM_SPECIFICATION);
832 return 0;
835 return ret;
838 static void kvm_handle_diag_308(S390CPU *cpu, struct kvm_run *run)
840 uint64_t r1, r3;
842 cpu_synchronize_state(CPU(cpu));
843 r1 = (run->s390_sieic.ipa & 0x00f0) >> 8;
844 r3 = run->s390_sieic.ipa & 0x000f;
845 handle_diag_308(&cpu->env, r1, r3);
848 static int handle_sw_breakpoint(S390CPU *cpu, struct kvm_run *run)
850 CPUS390XState *env = &cpu->env;
851 unsigned long pc;
853 cpu_synchronize_state(CPU(cpu));
855 pc = env->psw.addr - 4;
856 if (kvm_find_sw_breakpoint(CPU(cpu), pc)) {
857 env->psw.addr = pc;
858 return EXCP_DEBUG;
861 return -ENOENT;
864 #define DIAG_KVM_CODE_MASK 0x000000000000ffff
866 static int handle_diag(S390CPU *cpu, struct kvm_run *run, uint32_t ipb)
868 int r = 0;
869 uint16_t func_code;
872 * For any diagnose call we support, bits 48-63 of the resulting
873 * address specify the function code; the remainder is ignored.
875 func_code = decode_basedisp_rs(&cpu->env, ipb) & DIAG_KVM_CODE_MASK;
876 switch (func_code) {
877 case DIAG_IPL:
878 kvm_handle_diag_308(cpu, run);
879 break;
880 case DIAG_KVM_HYPERCALL:
881 r = handle_hypercall(cpu, run);
882 break;
883 case DIAG_KVM_BREAKPOINT:
884 r = handle_sw_breakpoint(cpu, run);
885 break;
886 default:
887 DPRINTF("KVM: unknown DIAG: 0x%x\n", func_code);
888 r = -1;
889 break;
892 return r;
895 static int kvm_s390_cpu_start(S390CPU *cpu)
897 s390_add_running_cpu(cpu);
898 qemu_cpu_kick(CPU(cpu));
899 DPRINTF("DONE: KVM cpu start: %p\n", &cpu->env);
900 return 0;
903 int kvm_s390_cpu_restart(S390CPU *cpu)
905 struct kvm_s390_irq irq = {
906 .type = KVM_S390_RESTART,
909 kvm_s390_vcpu_interrupt(cpu, &irq);
910 s390_add_running_cpu(cpu);
911 qemu_cpu_kick(CPU(cpu));
912 DPRINTF("DONE: KVM cpu restart: %p\n", &cpu->env);
913 return 0;
916 static void sigp_initial_cpu_reset(void *arg)
918 CPUState *cpu = arg;
919 S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
921 cpu_synchronize_state(cpu);
922 scc->initial_cpu_reset(cpu);
925 static void sigp_cpu_reset(void *arg)
927 CPUState *cpu = arg;
928 S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
930 cpu_synchronize_state(cpu);
931 scc->cpu_reset(cpu);
934 #define SIGP_ORDER_MASK 0x000000ff
936 static int handle_sigp(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
938 CPUS390XState *env = &cpu->env;
939 uint8_t order_code;
940 uint16_t cpu_addr;
941 S390CPU *target_cpu;
942 uint64_t *statusreg = &env->regs[ipa1 >> 4];
943 int cc;
945 cpu_synchronize_state(CPU(cpu));
947 /* get order code */
948 order_code = decode_basedisp_rs(env, run->s390_sieic.ipb) & SIGP_ORDER_MASK;
950 cpu_addr = env->regs[ipa1 & 0x0f];
951 target_cpu = s390_cpu_addr2state(cpu_addr);
952 if (target_cpu == NULL) {
953 cc = 3; /* not operational */
954 goto out;
957 switch (order_code) {
958 case SIGP_START:
959 cc = kvm_s390_cpu_start(target_cpu);
960 break;
961 case SIGP_RESTART:
962 cc = kvm_s390_cpu_restart(target_cpu);
963 break;
964 case SIGP_SET_ARCH:
965 *statusreg &= 0xffffffff00000000UL;
966 *statusreg |= SIGP_STAT_INVALID_PARAMETER;
967 cc = 1; /* status stored */
968 break;
969 case SIGP_INITIAL_CPU_RESET:
970 run_on_cpu(CPU(target_cpu), sigp_initial_cpu_reset, CPU(target_cpu));
971 cc = 0;
972 break;
973 case SIGP_CPU_RESET:
974 run_on_cpu(CPU(target_cpu), sigp_cpu_reset, CPU(target_cpu));
975 cc = 0;
976 break;
977 default:
978 DPRINTF("KVM: unknown SIGP: 0x%x\n", order_code);
979 *statusreg &= 0xffffffff00000000UL;
980 *statusreg |= SIGP_STAT_INVALID_ORDER;
981 cc = 1; /* status stored */
982 break;
985 out:
986 setcc(cpu, cc);
987 return 0;
990 static int handle_instruction(S390CPU *cpu, struct kvm_run *run)
992 unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
993 uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
994 int r = -1;
996 DPRINTF("handle_instruction 0x%x 0x%x\n",
997 run->s390_sieic.ipa, run->s390_sieic.ipb);
998 switch (ipa0) {
999 case IPA0_B2:
1000 r = handle_b2(cpu, run, ipa1);
1001 break;
1002 case IPA0_B9:
1003 r = handle_b9(cpu, run, ipa1);
1004 break;
1005 case IPA0_EB:
1006 r = handle_eb(cpu, run, ipa1);
1007 break;
1008 case IPA0_DIAG:
1009 r = handle_diag(cpu, run, run->s390_sieic.ipb);
1010 break;
1011 case IPA0_SIGP:
1012 r = handle_sigp(cpu, run, ipa1);
1013 break;
1016 if (r < 0) {
1017 r = 0;
1018 enter_pgmcheck(cpu, 0x0001);
1021 return r;
1024 static bool is_special_wait_psw(CPUState *cs)
1026 /* signal quiesce */
1027 return cs->kvm_run->psw_addr == 0xfffUL;
1030 static void guest_panicked(void)
1032 QObject *data;
1034 data = qobject_from_jsonf("{ 'action': %s }", "pause");
1035 monitor_protocol_event(QEVENT_GUEST_PANICKED, data);
1036 qobject_decref(data);
1038 vm_stop(RUN_STATE_GUEST_PANICKED);
1041 static void unmanageable_intercept(S390CPU *cpu, const char *str, int pswoffset)
1043 CPUState *cs = CPU(cpu);
1045 error_report("Unmanageable %s! CPU%i new PSW: 0x%016lx:%016lx",
1046 str, cs->cpu_index, ldq_phys(cs->as, cpu->env.psa + pswoffset),
1047 ldq_phys(cs->as, cpu->env.psa + pswoffset + 8));
1048 s390_del_running_cpu(cpu);
1049 guest_panicked();
1052 static int handle_intercept(S390CPU *cpu)
1054 CPUState *cs = CPU(cpu);
1055 struct kvm_run *run = cs->kvm_run;
1056 int icpt_code = run->s390_sieic.icptcode;
1057 int r = 0;
1059 DPRINTF("intercept: 0x%x (at 0x%lx)\n", icpt_code,
1060 (long)cs->kvm_run->psw_addr);
1061 switch (icpt_code) {
1062 case ICPT_INSTRUCTION:
1063 r = handle_instruction(cpu, run);
1064 break;
1065 case ICPT_PROGRAM:
1066 unmanageable_intercept(cpu, "program interrupt",
1067 offsetof(LowCore, program_new_psw));
1068 r = EXCP_HALTED;
1069 break;
1070 case ICPT_EXT_INT:
1071 unmanageable_intercept(cpu, "external interrupt",
1072 offsetof(LowCore, external_new_psw));
1073 r = EXCP_HALTED;
1074 break;
1075 case ICPT_WAITPSW:
1076 /* disabled wait, since enabled wait is handled in kernel */
1077 if (s390_del_running_cpu(cpu) == 0) {
1078 if (is_special_wait_psw(cs)) {
1079 qemu_system_shutdown_request();
1080 } else {
1081 guest_panicked();
1084 r = EXCP_HALTED;
1085 break;
1086 case ICPT_CPU_STOP:
1087 if (s390_del_running_cpu(cpu) == 0) {
1088 qemu_system_shutdown_request();
1090 r = EXCP_HALTED;
1091 break;
1092 case ICPT_SOFT_INTERCEPT:
1093 fprintf(stderr, "KVM unimplemented icpt SOFT\n");
1094 exit(1);
1095 break;
1096 case ICPT_IO:
1097 fprintf(stderr, "KVM unimplemented icpt IO\n");
1098 exit(1);
1099 break;
1100 default:
1101 fprintf(stderr, "Unknown intercept code: %d\n", icpt_code);
1102 exit(1);
1103 break;
1106 return r;
1109 static int handle_tsch(S390CPU *cpu)
1111 CPUS390XState *env = &cpu->env;
1112 CPUState *cs = CPU(cpu);
1113 struct kvm_run *run = cs->kvm_run;
1114 int ret;
1116 cpu_synchronize_state(cs);
1118 ret = ioinst_handle_tsch(env, env->regs[1], run->s390_tsch.ipb);
1119 if (ret >= 0) {
1120 /* Success; set condition code. */
1121 setcc(cpu, ret);
1122 ret = 0;
1123 } else if (ret < -1) {
1125 * Failure.
1126 * If an I/O interrupt had been dequeued, we have to reinject it.
1128 if (run->s390_tsch.dequeued) {
1129 kvm_s390_io_interrupt(run->s390_tsch.subchannel_id,
1130 run->s390_tsch.subchannel_nr,
1131 run->s390_tsch.io_int_parm,
1132 run->s390_tsch.io_int_word);
1134 ret = 0;
1136 return ret;
1139 static int kvm_arch_handle_debug_exit(S390CPU *cpu)
1141 CPUState *cs = CPU(cpu);
1142 struct kvm_run *run = cs->kvm_run;
1144 int ret = 0;
1145 struct kvm_debug_exit_arch *arch_info = &run->debug.arch;
1147 switch (arch_info->type) {
1148 case KVM_HW_WP_WRITE:
1149 if (find_hw_breakpoint(arch_info->addr, -1, arch_info->type)) {
1150 cs->watchpoint_hit = &hw_watchpoint;
1151 hw_watchpoint.vaddr = arch_info->addr;
1152 hw_watchpoint.flags = BP_MEM_WRITE;
1153 ret = EXCP_DEBUG;
1155 break;
1156 case KVM_HW_BP:
1157 if (find_hw_breakpoint(arch_info->addr, -1, arch_info->type)) {
1158 ret = EXCP_DEBUG;
1160 break;
1161 case KVM_SINGLESTEP:
1162 if (cs->singlestep_enabled) {
1163 ret = EXCP_DEBUG;
1165 break;
1166 default:
1167 ret = -ENOSYS;
1170 return ret;
1173 int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
1175 S390CPU *cpu = S390_CPU(cs);
1176 int ret = 0;
1178 switch (run->exit_reason) {
1179 case KVM_EXIT_S390_SIEIC:
1180 ret = handle_intercept(cpu);
1181 break;
1182 case KVM_EXIT_S390_RESET:
1183 qemu_system_reset_request();
1184 break;
1185 case KVM_EXIT_S390_TSCH:
1186 ret = handle_tsch(cpu);
1187 break;
1188 case KVM_EXIT_DEBUG:
1189 ret = kvm_arch_handle_debug_exit(cpu);
1190 break;
1191 default:
1192 fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
1193 break;
1196 if (ret == 0) {
1197 ret = EXCP_INTERRUPT;
1199 return ret;
1202 bool kvm_arch_stop_on_emulation_error(CPUState *cpu)
1204 return true;
1207 int kvm_arch_on_sigbus_vcpu(CPUState *cpu, int code, void *addr)
1209 return 1;
1212 int kvm_arch_on_sigbus(int code, void *addr)
1214 return 1;
1217 void kvm_s390_io_interrupt(uint16_t subchannel_id,
1218 uint16_t subchannel_nr, uint32_t io_int_parm,
1219 uint32_t io_int_word)
1221 struct kvm_s390_irq irq = {
1222 .u.io.subchannel_id = subchannel_id,
1223 .u.io.subchannel_nr = subchannel_nr,
1224 .u.io.io_int_parm = io_int_parm,
1225 .u.io.io_int_word = io_int_word,
1228 if (io_int_word & IO_INT_WORD_AI) {
1229 irq.type = KVM_S390_INT_IO(1, 0, 0, 0);
1230 } else {
1231 irq.type = ((subchannel_id & 0xff00) << 24) |
1232 ((subchannel_id & 0x00060) << 22) | (subchannel_nr << 16);
1234 kvm_s390_floating_interrupt(&irq);
1237 void kvm_s390_crw_mchk(void)
1239 struct kvm_s390_irq irq = {
1240 .type = KVM_S390_MCHK,
1241 .u.mchk.cr14 = 1 << 28,
1242 .u.mchk.mcic = 0x00400f1d40330000,
1244 kvm_s390_floating_interrupt(&irq);
1247 void kvm_s390_enable_css_support(S390CPU *cpu)
1249 int r;
1251 /* Activate host kernel channel subsystem support. */
1252 r = kvm_vcpu_enable_cap(CPU(cpu), KVM_CAP_S390_CSS_SUPPORT, 0);
1253 assert(r == 0);
1256 void kvm_arch_init_irq_routing(KVMState *s)
1259 * Note that while irqchip capabilities generally imply that cpustates
1260 * are handled in-kernel, it is not true for s390 (yet); therefore, we
1261 * have to override the common code kvm_halt_in_kernel_allowed setting.
1263 if (kvm_check_extension(s, KVM_CAP_IRQ_ROUTING)) {
1264 kvm_irqfds_allowed = true;
1265 kvm_gsi_routing_allowed = true;
1266 kvm_halt_in_kernel_allowed = false;
1270 int kvm_s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch,
1271 int vq, bool assign)
1273 struct kvm_ioeventfd kick = {
1274 .flags = KVM_IOEVENTFD_FLAG_VIRTIO_CCW_NOTIFY |
1275 KVM_IOEVENTFD_FLAG_DATAMATCH,
1276 .fd = event_notifier_get_fd(notifier),
1277 .datamatch = vq,
1278 .addr = sch,
1279 .len = 8,
1281 if (!kvm_check_extension(kvm_state, KVM_CAP_IOEVENTFD)) {
1282 return -ENOSYS;
1284 if (!assign) {
1285 kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
1287 return kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);