2 * QEMU S390x KVM implementation
4 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 #include <sys/types.h>
21 #include <sys/ioctl.h>
24 #include <linux/kvm.h>
25 #include <asm/ptrace.h>
27 #include "qemu-common.h"
28 #include "qemu-timer.h"
32 #include "device_tree.h"
34 /* #define DEBUG_KVM */
37 #define dprintf(fmt, ...) \
38 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
40 #define dprintf(fmt, ...) \
44 #define IPA0_DIAG 0x8300
45 #define IPA0_SIGP 0xae00
46 #define IPA0_PRIV 0xb200
48 #define PRIV_SCLP_CALL 0x20
49 #define DIAG_KVM_HYPERCALL 0x500
50 #define DIAG_KVM_BREAKPOINT 0x501
52 #define ICPT_INSTRUCTION 0x04
53 #define ICPT_WAITPSW 0x1c
54 #define ICPT_SOFT_INTERCEPT 0x24
55 #define ICPT_CPU_STOP 0x28
58 #define SIGP_RESTART 0x06
59 #define SIGP_INITIAL_CPU_RESET 0x0b
60 #define SIGP_STORE_STATUS_ADDR 0x0e
61 #define SIGP_SET_ARCH 0x12
63 const KVMCapabilityInfo kvm_arch_required_capabilities
[] = {
67 static int cap_sync_regs
;
69 int kvm_arch_init(KVMState
*s
)
71 cap_sync_regs
= kvm_check_extension(s
, KVM_CAP_SYNC_REGS
);
75 int kvm_arch_init_vcpu(CPUState
*cpu
)
77 CPUS390XState
*env
= &S390_CPU(cpu
)->env
;
80 if (kvm_vcpu_ioctl(env
, KVM_S390_INITIAL_RESET
, NULL
) < 0) {
81 perror("cannot init reset vcpu");
87 void kvm_arch_reset_vcpu(CPUState
*cpu
)
89 /* FIXME: add code to reset vcpu. */
92 int kvm_arch_put_registers(CPUState
*cs
, int level
)
94 S390CPU
*cpu
= S390_CPU(cs
);
95 CPUS390XState
*env
= &cpu
->env
;
96 struct kvm_sregs sregs
;
101 /* always save the PSW and the GPRS*/
102 env
->kvm_run
->psw_addr
= env
->psw
.addr
;
103 env
->kvm_run
->psw_mask
= env
->psw
.mask
;
105 if (cap_sync_regs
&& env
->kvm_run
->kvm_valid_regs
& KVM_SYNC_GPRS
) {
106 for (i
= 0; i
< 16; i
++) {
107 env
->kvm_run
->s
.regs
.gprs
[i
] = env
->regs
[i
];
108 env
->kvm_run
->kvm_dirty_regs
|= KVM_SYNC_GPRS
;
111 for (i
= 0; i
< 16; i
++) {
112 regs
.gprs
[i
] = env
->regs
[i
];
114 ret
= kvm_vcpu_ioctl(env
, KVM_SET_REGS
, ®s
);
120 /* Do we need to save more than that? */
121 if (level
== KVM_PUT_RUNTIME_STATE
) {
126 env
->kvm_run
->kvm_valid_regs
& KVM_SYNC_ACRS
&&
127 env
->kvm_run
->kvm_valid_regs
& KVM_SYNC_CRS
) {
128 for (i
= 0; i
< 16; i
++) {
129 env
->kvm_run
->s
.regs
.acrs
[i
] = env
->aregs
[i
];
130 env
->kvm_run
->s
.regs
.crs
[i
] = env
->cregs
[i
];
132 env
->kvm_run
->kvm_dirty_regs
|= KVM_SYNC_ACRS
;
133 env
->kvm_run
->kvm_dirty_regs
|= KVM_SYNC_CRS
;
135 for (i
= 0; i
< 16; i
++) {
136 sregs
.acrs
[i
] = env
->aregs
[i
];
137 sregs
.crs
[i
] = env
->cregs
[i
];
139 ret
= kvm_vcpu_ioctl(env
, KVM_SET_SREGS
, &sregs
);
145 /* Finally the prefix */
146 if (cap_sync_regs
&& env
->kvm_run
->kvm_valid_regs
& KVM_SYNC_PREFIX
) {
147 env
->kvm_run
->s
.regs
.prefix
= env
->psa
;
148 env
->kvm_run
->kvm_dirty_regs
|= KVM_SYNC_PREFIX
;
150 /* prefix is only supported via sync regs */
155 int kvm_arch_get_registers(CPUState
*cs
)
157 S390CPU
*cpu
= S390_CPU(cs
);
158 CPUS390XState
*env
= &cpu
->env
;
159 struct kvm_sregs sregs
;
160 struct kvm_regs regs
;
165 env
->psw
.addr
= env
->kvm_run
->psw_addr
;
166 env
->psw
.mask
= env
->kvm_run
->psw_mask
;
169 if (cap_sync_regs
&& env
->kvm_run
->kvm_valid_regs
& KVM_SYNC_GPRS
) {
170 for (i
= 0; i
< 16; i
++) {
171 env
->regs
[i
] = env
->kvm_run
->s
.regs
.gprs
[i
];
174 ret
= kvm_vcpu_ioctl(env
, KVM_GET_REGS
, ®s
);
178 for (i
= 0; i
< 16; i
++) {
179 env
->regs
[i
] = regs
.gprs
[i
];
183 /* The ACRS and CRS */
185 env
->kvm_run
->kvm_valid_regs
& KVM_SYNC_ACRS
&&
186 env
->kvm_run
->kvm_valid_regs
& KVM_SYNC_CRS
) {
187 for (i
= 0; i
< 16; i
++) {
188 env
->aregs
[i
] = env
->kvm_run
->s
.regs
.acrs
[i
];
189 env
->cregs
[i
] = env
->kvm_run
->s
.regs
.crs
[i
];
192 ret
= kvm_vcpu_ioctl(env
, KVM_GET_SREGS
, &sregs
);
196 for (i
= 0; i
< 16; i
++) {
197 env
->aregs
[i
] = sregs
.acrs
[i
];
198 env
->cregs
[i
] = sregs
.crs
[i
];
202 /* Finally the prefix */
203 if (cap_sync_regs
&& env
->kvm_run
->kvm_valid_regs
& KVM_SYNC_PREFIX
) {
204 env
->psa
= env
->kvm_run
->s
.regs
.prefix
;
206 /* no prefix without sync regs */
213 * Legacy layout for s390:
214 * Older S390 KVM requires the topmost vma of the RAM to be
215 * smaller than an system defined value, which is at least 256GB.
216 * Larger systems have larger values. We put the guest between
217 * the end of data segment (system break) and this value. We
218 * use 32GB as a base to have enough room for the system break
219 * to grow. We also have to use MAP parameters that avoid
220 * read-only mapping of guest pages.
222 static void *legacy_s390_alloc(ram_addr_t size
)
226 mem
= mmap((void *) 0x800000000ULL
, size
,
227 PROT_EXEC
|PROT_READ
|PROT_WRITE
,
228 MAP_SHARED
| MAP_ANONYMOUS
| MAP_FIXED
, -1, 0);
229 if (mem
== MAP_FAILED
) {
230 fprintf(stderr
, "Allocating RAM failed\n");
236 void *kvm_arch_vmalloc(ram_addr_t size
)
238 /* Can we use the standard allocation ? */
239 if (kvm_check_extension(kvm_state
, KVM_CAP_S390_GMAP
) &&
240 kvm_check_extension(kvm_state
, KVM_CAP_S390_COW
)) {
243 return legacy_s390_alloc(size
);
247 int kvm_arch_insert_sw_breakpoint(CPUState
*cs
, struct kvm_sw_breakpoint
*bp
)
249 S390CPU
*cpu
= S390_CPU(cs
);
250 CPUS390XState
*env
= &cpu
->env
;
251 static const uint8_t diag_501
[] = {0x83, 0x24, 0x05, 0x01};
253 if (cpu_memory_rw_debug(env
, bp
->pc
, (uint8_t *)&bp
->saved_insn
, 4, 0) ||
254 cpu_memory_rw_debug(env
, bp
->pc
, (uint8_t *)diag_501
, 4, 1)) {
260 int kvm_arch_remove_sw_breakpoint(CPUState
*cs
, struct kvm_sw_breakpoint
*bp
)
262 S390CPU
*cpu
= S390_CPU(cs
);
263 CPUS390XState
*env
= &cpu
->env
;
265 static const uint8_t diag_501
[] = {0x83, 0x24, 0x05, 0x01};
267 if (cpu_memory_rw_debug(env
, bp
->pc
, t
, 4, 0)) {
269 } else if (memcmp(t
, diag_501
, 4)) {
271 } else if (cpu_memory_rw_debug(env
, bp
->pc
, (uint8_t *)&bp
->saved_insn
, 1, 1)) {
278 void kvm_arch_pre_run(CPUState
*cpu
, struct kvm_run
*run
)
282 void kvm_arch_post_run(CPUState
*cpu
, struct kvm_run
*run
)
286 int kvm_arch_process_async_events(CPUState
*cs
)
288 S390CPU
*cpu
= S390_CPU(cs
);
289 return cpu
->env
.halted
;
292 void kvm_s390_interrupt_internal(CPUS390XState
*env
, int type
, uint32_t parm
,
293 uint64_t parm64
, int vm
)
295 struct kvm_s390_interrupt kvmint
;
298 if (!env
->kvm_state
) {
304 kvmint
.parm64
= parm64
;
307 r
= kvm_vm_ioctl(env
->kvm_state
, KVM_S390_INTERRUPT
, &kvmint
);
309 r
= kvm_vcpu_ioctl(env
, KVM_S390_INTERRUPT
, &kvmint
);
313 fprintf(stderr
, "KVM failed to inject interrupt\n");
318 void kvm_s390_virtio_irq(CPUS390XState
*env
, int config_change
, uint64_t token
)
320 kvm_s390_interrupt_internal(env
, KVM_S390_INT_VIRTIO
, config_change
,
324 void kvm_s390_interrupt(CPUS390XState
*env
, int type
, uint32_t code
)
326 kvm_s390_interrupt_internal(env
, type
, code
, 0, 0);
329 static void enter_pgmcheck(CPUS390XState
*env
, uint16_t code
)
331 kvm_s390_interrupt(env
, KVM_S390_PROGRAM_INT
, code
);
334 static inline void setcc(CPUS390XState
*env
, uint64_t cc
)
336 env
->kvm_run
->psw_mask
&= ~(3ull << 44);
337 env
->kvm_run
->psw_mask
|= (cc
& 3) << 44;
339 env
->psw
.mask
&= ~(3ul << 44);
340 env
->psw
.mask
|= (cc
& 3) << 44;
343 static int kvm_sclp_service_call(CPUS390XState
*env
, struct kvm_run
*run
,
350 cpu_synchronize_state(env
);
351 sccb
= env
->regs
[ipbh0
& 0xf];
352 code
= env
->regs
[(ipbh0
& 0xf0) >> 4];
354 r
= sclp_service_call(sccb
, code
);
356 enter_pgmcheck(env
, -r
);
363 static int handle_priv(CPUS390XState
*env
, struct kvm_run
*run
, uint8_t ipa1
)
366 uint16_t ipbh0
= (run
->s390_sieic
.ipb
& 0xffff0000) >> 16;
368 dprintf("KVM: PRIV: %d\n", ipa1
);
371 r
= kvm_sclp_service_call(env
, run
, ipbh0
);
374 dprintf("KVM: unknown PRIV: 0x%x\n", ipa1
);
382 static int handle_hypercall(CPUS390XState
*env
, struct kvm_run
*run
)
384 cpu_synchronize_state(env
);
385 env
->regs
[2] = s390_virtio_hypercall(env
, env
->regs
[2], env
->regs
[1]);
390 static int handle_diag(CPUS390XState
*env
, struct kvm_run
*run
, int ipb_code
)
395 case DIAG_KVM_HYPERCALL
:
396 r
= handle_hypercall(env
, run
);
398 case DIAG_KVM_BREAKPOINT
:
402 dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code
);
410 static int s390_cpu_restart(S390CPU
*cpu
)
412 CPUS390XState
*env
= &cpu
->env
;
414 kvm_s390_interrupt(env
, KVM_S390_RESTART
, 0);
415 s390_add_running_cpu(env
);
416 qemu_cpu_kick(CPU(cpu
));
417 dprintf("DONE: SIGP cpu restart: %p\n", env
);
421 static int s390_store_status(CPUS390XState
*env
, uint32_t parameter
)
424 fprintf(stderr
, "XXX SIGP store status\n");
428 static int s390_cpu_initial_reset(CPUS390XState
*env
)
432 s390_del_running_cpu(env
);
433 if (kvm_vcpu_ioctl(env
, KVM_S390_INITIAL_RESET
, NULL
) < 0) {
434 perror("cannot init reset vcpu");
437 /* Manually zero out all registers */
438 cpu_synchronize_state(env
);
439 for (i
= 0; i
< 16; i
++) {
443 dprintf("DONE: SIGP initial reset: %p\n", env
);
447 static int handle_sigp(CPUS390XState
*env
, struct kvm_run
*run
, uint8_t ipa1
)
455 CPUS390XState
*target_env
;
457 cpu_synchronize_state(env
);
460 order_code
= run
->s390_sieic
.ipb
>> 28;
461 if (order_code
> 0) {
462 order_code
= env
->regs
[order_code
];
464 order_code
+= (run
->s390_sieic
.ipb
& 0x0fff0000) >> 16;
467 t
= (ipa1
& 0xf0) >> 4;
472 parameter
= env
->regs
[t
] & 0x7ffffe00;
473 cpu_addr
= env
->regs
[ipa1
& 0x0f];
475 target_cpu
= s390_cpu_addr2state(cpu_addr
);
476 if (target_cpu
== NULL
) {
479 target_env
= &target_cpu
->env
;
481 switch (order_code
) {
483 r
= s390_cpu_restart(target_cpu
);
485 case SIGP_STORE_STATUS_ADDR
:
486 r
= s390_store_status(target_env
, parameter
);
489 /* make the caller panic */
491 case SIGP_INITIAL_CPU_RESET
:
492 r
= s390_cpu_initial_reset(target_env
);
495 fprintf(stderr
, "KVM: unknown SIGP: 0x%x\n", order_code
);
500 setcc(env
, r
? 3 : 0);
504 static int handle_instruction(CPUS390XState
*env
, struct kvm_run
*run
)
506 unsigned int ipa0
= (run
->s390_sieic
.ipa
& 0xff00);
507 uint8_t ipa1
= run
->s390_sieic
.ipa
& 0x00ff;
508 int ipb_code
= (run
->s390_sieic
.ipb
& 0x0fff0000) >> 16;
511 dprintf("handle_instruction 0x%x 0x%x\n", run
->s390_sieic
.ipa
, run
->s390_sieic
.ipb
);
514 r
= handle_priv(env
, run
, ipa1
);
517 r
= handle_diag(env
, run
, ipb_code
);
520 r
= handle_sigp(env
, run
, ipa1
);
525 enter_pgmcheck(env
, 0x0001);
530 static bool is_special_wait_psw(CPUS390XState
*env
)
533 return env
->kvm_run
->psw_addr
== 0xfffUL
;
536 static int handle_intercept(CPUS390XState
*env
)
538 struct kvm_run
*run
= env
->kvm_run
;
539 int icpt_code
= run
->s390_sieic
.icptcode
;
542 dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code
,
543 (long)env
->kvm_run
->psw_addr
);
545 case ICPT_INSTRUCTION
:
546 r
= handle_instruction(env
, run
);
549 if (s390_del_running_cpu(env
) == 0 &&
550 is_special_wait_psw(env
)) {
551 qemu_system_shutdown_request();
556 if (s390_del_running_cpu(env
) == 0) {
557 qemu_system_shutdown_request();
561 case ICPT_SOFT_INTERCEPT
:
562 fprintf(stderr
, "KVM unimplemented icpt SOFT\n");
566 fprintf(stderr
, "KVM unimplemented icpt IO\n");
570 fprintf(stderr
, "Unknown intercept code: %d\n", icpt_code
);
578 int kvm_arch_handle_exit(CPUState
*cs
, struct kvm_run
*run
)
580 S390CPU
*cpu
= S390_CPU(cs
);
581 CPUS390XState
*env
= &cpu
->env
;
584 switch (run
->exit_reason
) {
585 case KVM_EXIT_S390_SIEIC
:
586 ret
= handle_intercept(env
);
588 case KVM_EXIT_S390_RESET
:
589 qemu_system_reset_request();
592 fprintf(stderr
, "Unknown KVM exit: %d\n", run
->exit_reason
);
597 ret
= EXCP_INTERRUPT
;
602 bool kvm_arch_stop_on_emulation_error(CPUState
*cpu
)
607 int kvm_arch_on_sigbus_vcpu(CPUState
*cpu
, int code
, void *addr
)
612 int kvm_arch_on_sigbus(int code
, void *addr
)