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>
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"
36 #include "sysemu/device_tree.h"
38 /* #define DEBUG_KVM */
41 #define dprintf(fmt, ...) \
42 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
44 #define dprintf(fmt, ...) \
48 #define IPA0_DIAG 0x8300
49 #define IPA0_SIGP 0xae00
50 #define IPA0_PRIV 0xb200
52 #define PRIV_SCLP_CALL 0x20
53 #define DIAG_KVM_HYPERCALL 0x500
54 #define DIAG_KVM_BREAKPOINT 0x501
56 #define ICPT_INSTRUCTION 0x04
57 #define ICPT_WAITPSW 0x1c
58 #define ICPT_SOFT_INTERCEPT 0x24
59 #define ICPT_CPU_STOP 0x28
62 #define SIGP_RESTART 0x06
63 #define SIGP_INITIAL_CPU_RESET 0x0b
64 #define SIGP_STORE_STATUS_ADDR 0x0e
65 #define SIGP_SET_ARCH 0x12
67 const KVMCapabilityInfo kvm_arch_required_capabilities
[] = {
71 static int cap_sync_regs
;
73 int kvm_arch_init(KVMState
*s
)
75 cap_sync_regs
= kvm_check_extension(s
, KVM_CAP_SYNC_REGS
);
79 unsigned long kvm_arch_vcpu_id(CPUState
*cpu
)
81 return cpu
->cpu_index
;
84 int kvm_arch_init_vcpu(CPUState
*cpu
)
88 if (kvm_vcpu_ioctl(cpu
, KVM_S390_INITIAL_RESET
, NULL
) < 0) {
89 perror("cannot init reset vcpu");
95 void kvm_arch_reset_vcpu(CPUState
*cpu
)
97 /* The initial reset call is needed here to reset in-kernel
98 * vcpu data that we can't access directly from QEMU
99 * (i.e. with older kernels which don't support sync_regs/ONE_REG).
100 * Before this ioctl cpu_synchronize_state() is called in common kvm
102 if (kvm_vcpu_ioctl(cpu
, KVM_S390_INITIAL_RESET
, NULL
)) {
103 perror("Can't reset vcpu\n");
107 int kvm_arch_put_registers(CPUState
*cs
, int level
)
109 S390CPU
*cpu
= S390_CPU(cs
);
110 CPUS390XState
*env
= &cpu
->env
;
111 struct kvm_sregs sregs
;
112 struct kvm_regs regs
;
116 /* always save the PSW and the GPRS*/
117 cs
->kvm_run
->psw_addr
= env
->psw
.addr
;
118 cs
->kvm_run
->psw_mask
= env
->psw
.mask
;
120 if (cap_sync_regs
&& cs
->kvm_run
->kvm_valid_regs
& KVM_SYNC_GPRS
) {
121 for (i
= 0; i
< 16; i
++) {
122 cs
->kvm_run
->s
.regs
.gprs
[i
] = env
->regs
[i
];
123 cs
->kvm_run
->kvm_dirty_regs
|= KVM_SYNC_GPRS
;
126 for (i
= 0; i
< 16; i
++) {
127 regs
.gprs
[i
] = env
->regs
[i
];
129 ret
= kvm_vcpu_ioctl(cs
, KVM_SET_REGS
, ®s
);
135 /* Do we need to save more than that? */
136 if (level
== KVM_PUT_RUNTIME_STATE
) {
141 cs
->kvm_run
->kvm_valid_regs
& KVM_SYNC_ACRS
&&
142 cs
->kvm_run
->kvm_valid_regs
& KVM_SYNC_CRS
) {
143 for (i
= 0; i
< 16; i
++) {
144 cs
->kvm_run
->s
.regs
.acrs
[i
] = env
->aregs
[i
];
145 cs
->kvm_run
->s
.regs
.crs
[i
] = env
->cregs
[i
];
147 cs
->kvm_run
->kvm_dirty_regs
|= KVM_SYNC_ACRS
;
148 cs
->kvm_run
->kvm_dirty_regs
|= KVM_SYNC_CRS
;
150 for (i
= 0; i
< 16; i
++) {
151 sregs
.acrs
[i
] = env
->aregs
[i
];
152 sregs
.crs
[i
] = env
->cregs
[i
];
154 ret
= kvm_vcpu_ioctl(cs
, KVM_SET_SREGS
, &sregs
);
160 /* Finally the prefix */
161 if (cap_sync_regs
&& cs
->kvm_run
->kvm_valid_regs
& KVM_SYNC_PREFIX
) {
162 cs
->kvm_run
->s
.regs
.prefix
= env
->psa
;
163 cs
->kvm_run
->kvm_dirty_regs
|= KVM_SYNC_PREFIX
;
165 /* prefix is only supported via sync regs */
170 int kvm_arch_get_registers(CPUState
*cs
)
172 S390CPU
*cpu
= S390_CPU(cs
);
173 CPUS390XState
*env
= &cpu
->env
;
174 struct kvm_sregs sregs
;
175 struct kvm_regs regs
;
180 env
->psw
.addr
= cs
->kvm_run
->psw_addr
;
181 env
->psw
.mask
= cs
->kvm_run
->psw_mask
;
184 if (cap_sync_regs
&& cs
->kvm_run
->kvm_valid_regs
& KVM_SYNC_GPRS
) {
185 for (i
= 0; i
< 16; i
++) {
186 env
->regs
[i
] = cs
->kvm_run
->s
.regs
.gprs
[i
];
189 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_REGS
, ®s
);
193 for (i
= 0; i
< 16; i
++) {
194 env
->regs
[i
] = regs
.gprs
[i
];
198 /* The ACRS and CRS */
200 cs
->kvm_run
->kvm_valid_regs
& KVM_SYNC_ACRS
&&
201 cs
->kvm_run
->kvm_valid_regs
& KVM_SYNC_CRS
) {
202 for (i
= 0; i
< 16; i
++) {
203 env
->aregs
[i
] = cs
->kvm_run
->s
.regs
.acrs
[i
];
204 env
->cregs
[i
] = cs
->kvm_run
->s
.regs
.crs
[i
];
207 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_SREGS
, &sregs
);
211 for (i
= 0; i
< 16; i
++) {
212 env
->aregs
[i
] = sregs
.acrs
[i
];
213 env
->cregs
[i
] = sregs
.crs
[i
];
217 /* Finally the prefix */
218 if (cap_sync_regs
&& cs
->kvm_run
->kvm_valid_regs
& KVM_SYNC_PREFIX
) {
219 env
->psa
= cs
->kvm_run
->s
.regs
.prefix
;
221 /* no prefix without sync regs */
228 * Legacy layout for s390:
229 * Older S390 KVM requires the topmost vma of the RAM to be
230 * smaller than an system defined value, which is at least 256GB.
231 * Larger systems have larger values. We put the guest between
232 * the end of data segment (system break) and this value. We
233 * use 32GB as a base to have enough room for the system break
234 * to grow. We also have to use MAP parameters that avoid
235 * read-only mapping of guest pages.
237 static void *legacy_s390_alloc(ram_addr_t size
)
241 mem
= mmap((void *) 0x800000000ULL
, size
,
242 PROT_EXEC
|PROT_READ
|PROT_WRITE
,
243 MAP_SHARED
| MAP_ANONYMOUS
| MAP_FIXED
, -1, 0);
244 if (mem
== MAP_FAILED
) {
245 fprintf(stderr
, "Allocating RAM failed\n");
251 void *kvm_arch_vmalloc(ram_addr_t size
)
253 /* Can we use the standard allocation ? */
254 if (kvm_check_extension(kvm_state
, KVM_CAP_S390_GMAP
) &&
255 kvm_check_extension(kvm_state
, KVM_CAP_S390_COW
)) {
258 return legacy_s390_alloc(size
);
262 int kvm_arch_insert_sw_breakpoint(CPUState
*cs
, struct kvm_sw_breakpoint
*bp
)
264 S390CPU
*cpu
= S390_CPU(cs
);
265 CPUS390XState
*env
= &cpu
->env
;
266 static const uint8_t diag_501
[] = {0x83, 0x24, 0x05, 0x01};
268 if (cpu_memory_rw_debug(env
, bp
->pc
, (uint8_t *)&bp
->saved_insn
, 4, 0) ||
269 cpu_memory_rw_debug(env
, bp
->pc
, (uint8_t *)diag_501
, 4, 1)) {
275 int kvm_arch_remove_sw_breakpoint(CPUState
*cs
, struct kvm_sw_breakpoint
*bp
)
277 S390CPU
*cpu
= S390_CPU(cs
);
278 CPUS390XState
*env
= &cpu
->env
;
280 static const uint8_t diag_501
[] = {0x83, 0x24, 0x05, 0x01};
282 if (cpu_memory_rw_debug(env
, bp
->pc
, t
, 4, 0)) {
284 } else if (memcmp(t
, diag_501
, 4)) {
286 } else if (cpu_memory_rw_debug(env
, bp
->pc
, (uint8_t *)&bp
->saved_insn
, 1, 1)) {
293 void kvm_arch_pre_run(CPUState
*cpu
, struct kvm_run
*run
)
297 void kvm_arch_post_run(CPUState
*cpu
, struct kvm_run
*run
)
301 int kvm_arch_process_async_events(CPUState
*cs
)
303 S390CPU
*cpu
= S390_CPU(cs
);
304 return cpu
->env
.halted
;
307 void kvm_s390_interrupt_internal(S390CPU
*cpu
, int type
, uint32_t parm
,
308 uint64_t parm64
, int vm
)
310 CPUState
*cs
= CPU(cpu
);
311 struct kvm_s390_interrupt kvmint
;
314 if (!cs
->kvm_state
) {
320 kvmint
.parm64
= parm64
;
323 r
= kvm_vm_ioctl(cs
->kvm_state
, KVM_S390_INTERRUPT
, &kvmint
);
325 r
= kvm_vcpu_ioctl(cs
, KVM_S390_INTERRUPT
, &kvmint
);
329 fprintf(stderr
, "KVM failed to inject interrupt\n");
334 void kvm_s390_virtio_irq(S390CPU
*cpu
, int config_change
, uint64_t token
)
336 kvm_s390_interrupt_internal(cpu
, KVM_S390_INT_VIRTIO
, config_change
,
340 void kvm_s390_interrupt(S390CPU
*cpu
, int type
, uint32_t code
)
342 kvm_s390_interrupt_internal(cpu
, type
, code
, 0, 0);
345 static void enter_pgmcheck(S390CPU
*cpu
, uint16_t code
)
347 kvm_s390_interrupt(cpu
, KVM_S390_PROGRAM_INT
, code
);
350 static inline void setcc(S390CPU
*cpu
, uint64_t cc
)
352 CPUS390XState
*env
= &cpu
->env
;
353 CPUState
*cs
= CPU(cpu
);
355 cs
->kvm_run
->psw_mask
&= ~(3ull << 44);
356 cs
->kvm_run
->psw_mask
|= (cc
& 3) << 44;
358 env
->psw
.mask
&= ~(3ul << 44);
359 env
->psw
.mask
|= (cc
& 3) << 44;
362 static int kvm_sclp_service_call(S390CPU
*cpu
, struct kvm_run
*run
,
365 CPUS390XState
*env
= &cpu
->env
;
370 cpu_synchronize_state(env
);
371 sccb
= env
->regs
[ipbh0
& 0xf];
372 code
= env
->regs
[(ipbh0
& 0xf0) >> 4];
374 r
= sclp_service_call(sccb
, code
);
376 enter_pgmcheck(cpu
, -r
);
383 static int handle_priv(S390CPU
*cpu
, struct kvm_run
*run
, uint8_t ipa1
)
386 uint16_t ipbh0
= (run
->s390_sieic
.ipb
& 0xffff0000) >> 16;
388 dprintf("KVM: PRIV: %d\n", ipa1
);
391 r
= kvm_sclp_service_call(cpu
, run
, ipbh0
);
394 dprintf("KVM: unknown PRIV: 0x%x\n", ipa1
);
402 static int handle_hypercall(CPUS390XState
*env
, struct kvm_run
*run
)
404 cpu_synchronize_state(env
);
405 env
->regs
[2] = s390_virtio_hypercall(env
);
410 static int handle_diag(CPUS390XState
*env
, struct kvm_run
*run
, int ipb_code
)
415 case DIAG_KVM_HYPERCALL
:
416 r
= handle_hypercall(env
, run
);
418 case DIAG_KVM_BREAKPOINT
:
422 dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code
);
430 static int s390_cpu_restart(S390CPU
*cpu
)
432 CPUS390XState
*env
= &cpu
->env
;
434 kvm_s390_interrupt(cpu
, KVM_S390_RESTART
, 0);
435 s390_add_running_cpu(env
);
436 qemu_cpu_kick(CPU(cpu
));
437 dprintf("DONE: SIGP cpu restart: %p\n", env
);
441 static int s390_store_status(CPUS390XState
*env
, uint32_t parameter
)
444 fprintf(stderr
, "XXX SIGP store status\n");
448 static int s390_cpu_initial_reset(S390CPU
*cpu
)
450 CPUS390XState
*env
= &cpu
->env
;
453 s390_del_running_cpu(env
);
454 if (kvm_vcpu_ioctl(CPU(cpu
), KVM_S390_INITIAL_RESET
, NULL
) < 0) {
455 perror("cannot init reset vcpu");
458 /* Manually zero out all registers */
459 cpu_synchronize_state(env
);
460 for (i
= 0; i
< 16; i
++) {
464 dprintf("DONE: SIGP initial reset: %p\n", env
);
468 static int handle_sigp(S390CPU
*cpu
, struct kvm_run
*run
, uint8_t ipa1
)
470 CPUS390XState
*env
= &cpu
->env
;
477 CPUS390XState
*target_env
;
479 cpu_synchronize_state(env
);
482 order_code
= run
->s390_sieic
.ipb
>> 28;
483 if (order_code
> 0) {
484 order_code
= env
->regs
[order_code
];
486 order_code
+= (run
->s390_sieic
.ipb
& 0x0fff0000) >> 16;
489 t
= (ipa1
& 0xf0) >> 4;
494 parameter
= env
->regs
[t
] & 0x7ffffe00;
495 cpu_addr
= env
->regs
[ipa1
& 0x0f];
497 target_cpu
= s390_cpu_addr2state(cpu_addr
);
498 if (target_cpu
== NULL
) {
501 target_env
= &target_cpu
->env
;
503 switch (order_code
) {
505 r
= s390_cpu_restart(target_cpu
);
507 case SIGP_STORE_STATUS_ADDR
:
508 r
= s390_store_status(target_env
, parameter
);
511 /* make the caller panic */
513 case SIGP_INITIAL_CPU_RESET
:
514 r
= s390_cpu_initial_reset(target_cpu
);
517 fprintf(stderr
, "KVM: unknown SIGP: 0x%x\n", order_code
);
522 setcc(cpu
, r
? 3 : 0);
526 static int handle_instruction(S390CPU
*cpu
, struct kvm_run
*run
)
528 CPUS390XState
*env
= &cpu
->env
;
529 unsigned int ipa0
= (run
->s390_sieic
.ipa
& 0xff00);
530 uint8_t ipa1
= run
->s390_sieic
.ipa
& 0x00ff;
531 int ipb_code
= (run
->s390_sieic
.ipb
& 0x0fff0000) >> 16;
534 dprintf("handle_instruction 0x%x 0x%x\n", run
->s390_sieic
.ipa
, run
->s390_sieic
.ipb
);
537 r
= handle_priv(cpu
, run
, ipa1
);
540 r
= handle_diag(env
, run
, ipb_code
);
543 r
= handle_sigp(cpu
, run
, ipa1
);
548 enter_pgmcheck(cpu
, 0x0001);
553 static bool is_special_wait_psw(CPUState
*cs
)
556 return cs
->kvm_run
->psw_addr
== 0xfffUL
;
559 static int handle_intercept(S390CPU
*cpu
)
561 CPUS390XState
*env
= &cpu
->env
;
562 CPUState
*cs
= CPU(cpu
);
563 struct kvm_run
*run
= cs
->kvm_run
;
564 int icpt_code
= run
->s390_sieic
.icptcode
;
567 dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code
,
568 (long)cs
->kvm_run
->psw_addr
);
570 case ICPT_INSTRUCTION
:
571 r
= handle_instruction(cpu
, run
);
574 if (s390_del_running_cpu(env
) == 0 &&
575 is_special_wait_psw(cs
)) {
576 qemu_system_shutdown_request();
581 if (s390_del_running_cpu(env
) == 0) {
582 qemu_system_shutdown_request();
586 case ICPT_SOFT_INTERCEPT
:
587 fprintf(stderr
, "KVM unimplemented icpt SOFT\n");
591 fprintf(stderr
, "KVM unimplemented icpt IO\n");
595 fprintf(stderr
, "Unknown intercept code: %d\n", icpt_code
);
603 int kvm_arch_handle_exit(CPUState
*cs
, struct kvm_run
*run
)
605 S390CPU
*cpu
= S390_CPU(cs
);
608 switch (run
->exit_reason
) {
609 case KVM_EXIT_S390_SIEIC
:
610 ret
= handle_intercept(cpu
);
612 case KVM_EXIT_S390_RESET
:
613 qemu_system_reset_request();
616 fprintf(stderr
, "Unknown KVM exit: %d\n", run
->exit_reason
);
621 ret
= EXCP_INTERRUPT
;
626 bool kvm_arch_stop_on_emulation_error(CPUState
*cpu
)
631 int kvm_arch_on_sigbus_vcpu(CPUState
*cpu
, int code
, void *addr
)
636 int kvm_arch_on_sigbus(int code
, void *addr
)