| /* |
| * QEMU S390x KVM implementation |
| * |
| * Copyright (c) 2009 Alexander Graf <agraf@suse.de> |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include <sys/types.h> |
| #include <sys/ioctl.h> |
| #include <sys/mman.h> |
| |
| #include <linux/kvm.h> |
| #include <asm/ptrace.h> |
| |
| #include "qemu-common.h" |
| #include "qemu-timer.h" |
| #include "sysemu.h" |
| #include "kvm.h" |
| #include "cpu.h" |
| #include "device_tree.h" |
| |
| /* #define DEBUG_KVM */ |
| |
| #ifdef DEBUG_KVM |
| #define dprintf(fmt, ...) \ |
| do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) |
| #else |
| #define dprintf(fmt, ...) \ |
| do { } while (0) |
| #endif |
| |
| #define IPA0_DIAG 0x8300 |
| #define IPA0_SIGP 0xae00 |
| #define IPA0_PRIV 0xb200 |
| |
| #define PRIV_SCLP_CALL 0x20 |
| #define DIAG_KVM_HYPERCALL 0x500 |
| #define DIAG_KVM_BREAKPOINT 0x501 |
| |
| #define SCP_LENGTH 0x00 |
| #define SCP_FUNCTION_CODE 0x02 |
| #define SCP_CONTROL_MASK 0x03 |
| #define SCP_RESPONSE_CODE 0x06 |
| #define SCP_MEM_CODE 0x08 |
| #define SCP_INCREMENT 0x0a |
| |
| #define ICPT_INSTRUCTION 0x04 |
| #define ICPT_WAITPSW 0x1c |
| #define ICPT_SOFT_INTERCEPT 0x24 |
| #define ICPT_CPU_STOP 0x28 |
| #define ICPT_IO 0x40 |
| |
| #define SIGP_RESTART 0x06 |
| #define SIGP_INITIAL_CPU_RESET 0x0b |
| #define SIGP_STORE_STATUS_ADDR 0x0e |
| #define SIGP_SET_ARCH 0x12 |
| |
| #define SCLP_CMDW_READ_SCP_INFO 0x00020001 |
| #define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001 |
| |
| int kvm_arch_init(KVMState *s, int smp_cpus) |
| { |
| return 0; |
| } |
| |
| int kvm_arch_init_vcpu(CPUState *env) |
| { |
| int ret = 0; |
| |
| if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) { |
| perror("cannot init reset vcpu"); |
| } |
| |
| return ret; |
| } |
| |
| void kvm_arch_reset_vcpu(CPUState *env) |
| { |
| /* FIXME: add code to reset vcpu. */ |
| } |
| |
| int kvm_arch_put_registers(CPUState *env, int level) |
| { |
| struct kvm_regs regs; |
| int ret; |
| int i; |
| |
| ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, ®s); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| for (i = 0; i < 16; i++) { |
| regs.gprs[i] = env->regs[i]; |
| } |
| |
| ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, ®s); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| env->kvm_run->psw_addr = env->psw.addr; |
| env->kvm_run->psw_mask = env->psw.mask; |
| |
| return ret; |
| } |
| |
| int kvm_arch_get_registers(CPUState *env) |
| { |
| uint32_t ret; |
| struct kvm_regs regs; |
| int i; |
| |
| ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, ®s); |
| if (ret < 0) { |
| return ret; |
| } |
| |
| for (i = 0; i < 16; i++) { |
| env->regs[i] = regs.gprs[i]; |
| } |
| |
| env->psw.addr = env->kvm_run->psw_addr; |
| env->psw.mask = env->kvm_run->psw_mask; |
| |
| return 0; |
| } |
| |
| int kvm_arch_insert_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp) |
| { |
| static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01}; |
| |
| if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 4, 0) || |
| cpu_memory_rw_debug(env, bp->pc, (uint8_t *)diag_501, 4, 1)) { |
| return -EINVAL; |
| } |
| return 0; |
| } |
| |
| int kvm_arch_remove_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp) |
| { |
| uint8_t t[4]; |
| static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01}; |
| |
| if (cpu_memory_rw_debug(env, bp->pc, t, 4, 0)) { |
| return -EINVAL; |
| } else if (memcmp(t, diag_501, 4)) { |
| return -EINVAL; |
| } else if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) { |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| int kvm_arch_pre_run(CPUState *env, struct kvm_run *run) |
| { |
| return 0; |
| } |
| |
| int kvm_arch_post_run(CPUState *env, struct kvm_run *run) |
| { |
| return 0; |
| } |
| |
| int kvm_arch_process_irqchip_events(CPUState *env) |
| { |
| return 0; |
| } |
| |
| static void kvm_s390_interrupt_internal(CPUState *env, int type, uint32_t parm, |
| uint64_t parm64, int vm) |
| { |
| struct kvm_s390_interrupt kvmint; |
| int r; |
| |
| if (!env->kvm_state) { |
| return; |
| } |
| |
| env->halted = 0; |
| env->exception_index = -1; |
| |
| kvmint.type = type; |
| kvmint.parm = parm; |
| kvmint.parm64 = parm64; |
| |
| if (vm) { |
| r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint); |
| } else { |
| r = kvm_vcpu_ioctl(env, KVM_S390_INTERRUPT, &kvmint); |
| } |
| |
| if (r < 0) { |
| fprintf(stderr, "KVM failed to inject interrupt\n"); |
| exit(1); |
| } |
| } |
| |
| void kvm_s390_virtio_irq(CPUState *env, int config_change, uint64_t token) |
| { |
| kvm_s390_interrupt_internal(env, KVM_S390_INT_VIRTIO, config_change, |
| token, 1); |
| } |
| |
| static void kvm_s390_interrupt(CPUState *env, int type, uint32_t code) |
| { |
| kvm_s390_interrupt_internal(env, type, code, 0, 0); |
| } |
| |
| static void enter_pgmcheck(CPUState *env, uint16_t code) |
| { |
| kvm_s390_interrupt(env, KVM_S390_PROGRAM_INT, code); |
| } |
| |
| static void setcc(CPUState *env, uint64_t cc) |
| { |
| env->kvm_run->psw_mask &= ~(3ul << 44); |
| env->kvm_run->psw_mask |= (cc & 3) << 44; |
| |
| env->psw.mask &= ~(3ul << 44); |
| env->psw.mask |= (cc & 3) << 44; |
| } |
| |
| static int sclp_service_call(CPUState *env, struct kvm_run *run, uint16_t ipbh0) |
| { |
| uint32_t sccb; |
| uint64_t code; |
| int r = 0; |
| |
| cpu_synchronize_state(env); |
| sccb = env->regs[ipbh0 & 0xf]; |
| code = env->regs[(ipbh0 & 0xf0) >> 4]; |
| |
| dprintf("sclp(0x%x, 0x%lx)\n", sccb, code); |
| |
| if (sccb & ~0x7ffffff8ul) { |
| fprintf(stderr, "KVM: invalid sccb address 0x%x\n", sccb); |
| r = -1; |
| goto out; |
| } |
| |
| switch(code) { |
| case SCLP_CMDW_READ_SCP_INFO: |
| case SCLP_CMDW_READ_SCP_INFO_FORCED: |
| stw_phys(sccb + SCP_MEM_CODE, ram_size >> 20); |
| stb_phys(sccb + SCP_INCREMENT, 1); |
| stw_phys(sccb + SCP_RESPONSE_CODE, 0x10); |
| setcc(env, 0); |
| |
| kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE, |
| sccb & ~3, 0, 1); |
| break; |
| default: |
| dprintf("KVM: invalid sclp call 0x%x / 0x%lx\n", sccb, code); |
| r = -1; |
| break; |
| } |
| |
| out: |
| if (r < 0) { |
| setcc(env, 3); |
| } |
| return 0; |
| } |
| |
| static int handle_priv(CPUState *env, struct kvm_run *run, uint8_t ipa1) |
| { |
| int r = 0; |
| uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16; |
| |
| dprintf("KVM: PRIV: %d\n", ipa1); |
| switch (ipa1) { |
| case PRIV_SCLP_CALL: |
| r = sclp_service_call(env, run, ipbh0); |
| break; |
| default: |
| dprintf("KVM: unknown PRIV: 0x%x\n", ipa1); |
| r = -1; |
| break; |
| } |
| |
| return r; |
| } |
| |
| static int handle_hypercall(CPUState *env, struct kvm_run *run) |
| { |
| int r; |
| |
| cpu_synchronize_state(env); |
| r = s390_virtio_hypercall(env); |
| |
| return r; |
| } |
| |
| static int handle_diag(CPUState *env, struct kvm_run *run, int ipb_code) |
| { |
| int r = 0; |
| |
| switch (ipb_code) { |
| case DIAG_KVM_HYPERCALL: |
| r = handle_hypercall(env, run); |
| break; |
| case DIAG_KVM_BREAKPOINT: |
| sleep(10); |
| break; |
| default: |
| dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code); |
| r = -1; |
| break; |
| } |
| |
| return r; |
| } |
| |
| static int s390_cpu_restart(CPUState *env) |
| { |
| kvm_s390_interrupt(env, KVM_S390_RESTART, 0); |
| env->halted = 0; |
| env->exception_index = -1; |
| qemu_cpu_kick(env); |
| dprintf("DONE: SIGP cpu restart: %p\n", env); |
| return 0; |
| } |
| |
| static int s390_store_status(CPUState *env, uint32_t parameter) |
| { |
| /* XXX */ |
| fprintf(stderr, "XXX SIGP store status\n"); |
| return -1; |
| } |
| |
| static int s390_cpu_initial_reset(CPUState *env) |
| { |
| /* XXX */ |
| fprintf(stderr, "XXX SIGP init\n"); |
| return -1; |
| } |
| |
| static int handle_sigp(CPUState *env, struct kvm_run *run, uint8_t ipa1) |
| { |
| uint8_t order_code; |
| uint32_t parameter; |
| uint16_t cpu_addr; |
| uint8_t t; |
| int r = -1; |
| CPUState *target_env; |
| |
| cpu_synchronize_state(env); |
| |
| /* get order code */ |
| order_code = run->s390_sieic.ipb >> 28; |
| if (order_code > 0) { |
| order_code = env->regs[order_code]; |
| } |
| order_code += (run->s390_sieic.ipb & 0x0fff0000) >> 16; |
| |
| /* get parameters */ |
| t = (ipa1 & 0xf0) >> 4; |
| if (!(t % 2)) { |
| t++; |
| } |
| |
| parameter = env->regs[t] & 0x7ffffe00; |
| cpu_addr = env->regs[ipa1 & 0x0f]; |
| |
| target_env = s390_cpu_addr2state(cpu_addr); |
| if (!target_env) { |
| goto out; |
| } |
| |
| switch (order_code) { |
| case SIGP_RESTART: |
| r = s390_cpu_restart(target_env); |
| break; |
| case SIGP_STORE_STATUS_ADDR: |
| r = s390_store_status(target_env, parameter); |
| break; |
| case SIGP_SET_ARCH: |
| /* make the caller panic */ |
| return -1; |
| case SIGP_INITIAL_CPU_RESET: |
| r = s390_cpu_initial_reset(target_env); |
| break; |
| default: |
| fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", ipa1); |
| break; |
| } |
| |
| out: |
| setcc(env, r ? 3 : 0); |
| return 0; |
| } |
| |
| static int handle_instruction(CPUState *env, struct kvm_run *run) |
| { |
| unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00); |
| uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff; |
| int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16; |
| int r = -1; |
| |
| dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb); |
| switch (ipa0) { |
| case IPA0_PRIV: |
| r = handle_priv(env, run, ipa1); |
| break; |
| case IPA0_DIAG: |
| r = handle_diag(env, run, ipb_code); |
| break; |
| case IPA0_SIGP: |
| r = handle_sigp(env, run, ipa1); |
| break; |
| } |
| |
| if (r < 0) { |
| enter_pgmcheck(env, 0x0001); |
| } |
| return r; |
| } |
| |
| static int handle_intercept(CPUState *env) |
| { |
| struct kvm_run *run = env->kvm_run; |
| int icpt_code = run->s390_sieic.icptcode; |
| int r = 0; |
| |
| dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code, env->kvm_run->psw_addr); |
| switch (icpt_code) { |
| case ICPT_INSTRUCTION: |
| r = handle_instruction(env, run); |
| break; |
| case ICPT_WAITPSW: |
| /* XXX What to do on system shutdown? */ |
| env->halted = 1; |
| env->exception_index = EXCP_HLT; |
| break; |
| case ICPT_SOFT_INTERCEPT: |
| fprintf(stderr, "KVM unimplemented icpt SOFT\n"); |
| exit(1); |
| break; |
| case ICPT_CPU_STOP: |
| qemu_system_shutdown_request(); |
| break; |
| case ICPT_IO: |
| fprintf(stderr, "KVM unimplemented icpt IO\n"); |
| exit(1); |
| break; |
| default: |
| fprintf(stderr, "Unknown intercept code: %d\n", icpt_code); |
| exit(1); |
| break; |
| } |
| |
| return r; |
| } |
| |
| int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run) |
| { |
| int ret = 0; |
| |
| switch (run->exit_reason) { |
| case KVM_EXIT_S390_SIEIC: |
| ret = handle_intercept(env); |
| break; |
| case KVM_EXIT_S390_RESET: |
| fprintf(stderr, "RESET not implemented\n"); |
| exit(1); |
| break; |
| default: |
| fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason); |
| break; |
| } |
| |
| return ret; |
| } |
