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 SCP_LENGTH 0x00
53 #define SCP_FUNCTION_CODE 0x02
54 #define SCP_CONTROL_MASK 0x03
55 #define SCP_RESPONSE_CODE 0x06
56 #define SCP_MEM_CODE 0x08
57 #define SCP_INCREMENT 0x0a
59 #define ICPT_INSTRUCTION 0x04
60 #define ICPT_WAITPSW 0x1c
61 #define ICPT_SOFT_INTERCEPT 0x24
62 #define ICPT_CPU_STOP 0x28
65 #define SIGP_RESTART 0x06
66 #define SIGP_INITIAL_CPU_RESET 0x0b
67 #define SIGP_STORE_STATUS_ADDR 0x0e
68 #define SIGP_SET_ARCH 0x12
70 #define SCLP_CMDW_READ_SCP_INFO 0x00020001
71 #define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
73 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
77 int kvm_arch_init(KVMState *s)
82 int kvm_arch_init_vcpu(CPUState *env)
86 if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
87 perror("cannot init reset vcpu");
93 void kvm_arch_reset_vcpu(CPUState *env)
95 /* FIXME: add code to reset vcpu. */
98 int kvm_arch_put_registers(CPUState *env, int level)
100 struct kvm_regs regs;
104 ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, ®s);
109 for (i = 0; i < 16; i++) {
110 regs.gprs[i] = env->regs[i];
113 ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, ®s);
118 env->kvm_run->psw_addr = env->psw.addr;
119 env->kvm_run->psw_mask = env->psw.mask;
124 int kvm_arch_get_registers(CPUState *env)
127 struct kvm_regs regs;
130 ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, ®s);
135 for (i = 0; i < 16; i++) {
136 env->regs[i] = regs.gprs[i];
139 env->psw.addr = env->kvm_run->psw_addr;
140 env->psw.mask = env->kvm_run->psw_mask;
145 int kvm_arch_insert_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
147 static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
149 if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 4, 0) ||
150 cpu_memory_rw_debug(env, bp->pc, (uint8_t *)diag_501, 4, 1)) {
156 int kvm_arch_remove_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
159 static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
161 if (cpu_memory_rw_debug(env, bp->pc, t, 4, 0)) {
163 } else if (memcmp(t, diag_501, 4)) {
165 } else if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) {
172 int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
177 int kvm_arch_post_run(CPUState *env, struct kvm_run *run)
182 int kvm_arch_process_irqchip_events(CPUState *env)
187 static void kvm_s390_interrupt_internal(CPUState *env, int type, uint32_t parm,
188 uint64_t parm64, int vm)
190 struct kvm_s390_interrupt kvmint;
193 if (!env->kvm_state) {
198 env->exception_index = -1;
202 kvmint.parm64 = parm64;
205 r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint);
207 r = kvm_vcpu_ioctl(env, KVM_S390_INTERRUPT, &kvmint);
211 fprintf(stderr, "KVM failed to inject interrupt\n");
216 void kvm_s390_virtio_irq(CPUState *env, int config_change, uint64_t token)
218 kvm_s390_interrupt_internal(env, KVM_S390_INT_VIRTIO, config_change,
222 static void kvm_s390_interrupt(CPUState *env, int type, uint32_t code)
224 kvm_s390_interrupt_internal(env, type, code, 0, 0);
227 static void enter_pgmcheck(CPUState *env, uint16_t code)
229 kvm_s390_interrupt(env, KVM_S390_PROGRAM_INT, code);
232 static void setcc(CPUState *env, uint64_t cc)
234 env->kvm_run->psw_mask &= ~(3ul << 44);
235 env->kvm_run->psw_mask |= (cc & 3) << 44;
237 env->psw.mask &= ~(3ul << 44);
238 env->psw.mask |= (cc & 3) << 44;
241 static int sclp_service_call(CPUState *env, struct kvm_run *run, uint16_t ipbh0)
247 cpu_synchronize_state(env);
248 sccb = env->regs[ipbh0 & 0xf];
249 code = env->regs[(ipbh0 & 0xf0) >> 4];
251 dprintf("sclp(0x%x, 0x%lx)\n", sccb, code);
253 if (sccb & ~0x7ffffff8ul) {
254 fprintf(stderr, "KVM: invalid sccb address 0x%x\n", sccb);
260 case SCLP_CMDW_READ_SCP_INFO:
261 case SCLP_CMDW_READ_SCP_INFO_FORCED:
262 stw_phys(sccb + SCP_MEM_CODE, ram_size >> 20);
263 stb_phys(sccb + SCP_INCREMENT, 1);
264 stw_phys(sccb + SCP_RESPONSE_CODE, 0x10);
267 kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE,
271 dprintf("KVM: invalid sclp call 0x%x / 0x%lx\n", sccb, code);
283 static int handle_priv(CPUState *env, struct kvm_run *run, uint8_t ipa1)
286 uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
288 dprintf("KVM: PRIV: %d\n", ipa1);
291 r = sclp_service_call(env, run, ipbh0);
294 dprintf("KVM: unknown PRIV: 0x%x\n", ipa1);
302 static int handle_hypercall(CPUState *env, struct kvm_run *run)
306 cpu_synchronize_state(env);
307 r = s390_virtio_hypercall(env);
312 static int handle_diag(CPUState *env, struct kvm_run *run, int ipb_code)
317 case DIAG_KVM_HYPERCALL:
318 r = handle_hypercall(env, run);
320 case DIAG_KVM_BREAKPOINT:
324 dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code);
332 static int s390_cpu_restart(CPUState *env)
334 kvm_s390_interrupt(env, KVM_S390_RESTART, 0);
336 env->exception_index = -1;
338 dprintf("DONE: SIGP cpu restart: %p\n", env);
342 static int s390_store_status(CPUState *env, uint32_t parameter)
345 fprintf(stderr, "XXX SIGP store status\n");
349 static int s390_cpu_initial_reset(CPUState *env)
353 if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
354 perror("cannot init reset vcpu");
357 /* Manually zero out all registers */
358 cpu_synchronize_state(env);
359 for (i = 0; i < 16; i++) {
363 dprintf("DONE: SIGP initial reset: %p\n", env);
367 static int handle_sigp(CPUState *env, struct kvm_run *run, uint8_t ipa1)
374 CPUState *target_env;
376 cpu_synchronize_state(env);
379 order_code = run->s390_sieic.ipb >> 28;
380 if (order_code > 0) {
381 order_code = env->regs[order_code];
383 order_code += (run->s390_sieic.ipb & 0x0fff0000) >> 16;
386 t = (ipa1 & 0xf0) >> 4;
391 parameter = env->regs[t] & 0x7ffffe00;
392 cpu_addr = env->regs[ipa1 & 0x0f];
394 target_env = s390_cpu_addr2state(cpu_addr);
399 switch (order_code) {
401 r = s390_cpu_restart(target_env);
403 case SIGP_STORE_STATUS_ADDR:
404 r = s390_store_status(target_env, parameter);
407 /* make the caller panic */
409 case SIGP_INITIAL_CPU_RESET:
410 r = s390_cpu_initial_reset(target_env);
413 fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", ipa1);
418 setcc(env, r ? 3 : 0);
422 static int handle_instruction(CPUState *env, struct kvm_run *run)
424 unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
425 uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
426 int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;
429 dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb);
432 r = handle_priv(env, run, ipa1);
435 r = handle_diag(env, run, ipb_code);
438 r = handle_sigp(env, run, ipa1);
443 enter_pgmcheck(env, 0x0001);
448 static int handle_intercept(CPUState *env)
450 struct kvm_run *run = env->kvm_run;
451 int icpt_code = run->s390_sieic.icptcode;
454 dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code, env->kvm_run->psw_addr);
456 case ICPT_INSTRUCTION:
457 r = handle_instruction(env, run);
460 /* XXX What to do on system shutdown? */
462 env->exception_index = EXCP_HLT;
464 case ICPT_SOFT_INTERCEPT:
465 fprintf(stderr, "KVM unimplemented icpt SOFT\n");
469 qemu_system_shutdown_request();
472 fprintf(stderr, "KVM unimplemented icpt IO\n");
476 fprintf(stderr, "Unknown intercept code: %d\n", icpt_code);
484 int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run)
488 switch (run->exit_reason) {
489 case KVM_EXIT_S390_SIEIC:
490 ret = handle_intercept(env);
492 case KVM_EXIT_S390_RESET:
493 fprintf(stderr, "RESET not implemented\n");
497 fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
504 bool kvm_arch_stop_on_emulation_error(CPUState *env)