target-s390x/kvm.c

   1 /*
   2  * QEMU S390x KVM implementation
   3  *
   4  * Copyright (c) 2009 Alexander Graf <[email protected]>
   5  *
   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.
  10  *
  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.
  15  *
  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/>.
  18  */
  19
  20 #include <sys/types.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/mman.h>
  23
  24 #include <linux/kvm.h>
  25 #include <asm/ptrace.h>
  26
  27 #include "qemu-common.h"
  28 #include "qemu-timer.h"
  29 #include "sysemu.h"
  30 #include "kvm.h"
  31 #include "cpu.h"
  32 #include "device_tree.h"
  33
  34 /* #define DEBUG_KVM */
  35
  36 #ifdef DEBUG_KVM
  37 #define dprintf(fmt, ...) \
  38     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
  39 #else
  40 #define dprintf(fmt, ...) \
  41     do { } while (0)
  42 #endif
  43
  44 #define IPA0_DIAG                       0x8300
  45 #define IPA0_SIGP                       0xae00
  46 #define IPA0_PRIV                       0xb200
  47
  48 #define PRIV_SCLP_CALL                  0x20
  49 #define DIAG_KVM_HYPERCALL              0x500
  50 #define DIAG_KVM_BREAKPOINT             0x501
  51
  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
  58
  59 #define ICPT_INSTRUCTION                0x04
  60 #define ICPT_WAITPSW                    0x1c
  61 #define ICPT_SOFT_INTERCEPT             0x24
  62 #define ICPT_CPU_STOP                   0x28
  63 #define ICPT_IO                         0x40
  64
  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
  69
  70 #define SCLP_CMDW_READ_SCP_INFO         0x00020001
  71 #define SCLP_CMDW_READ_SCP_INFO_FORCED  0x00120001
  72
  73 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
  74     KVM_CAP_LAST_INFO
  75 };
  76
  77 int kvm_arch_init(KVMState *s)
  78 {
  79     return 0;
  80 }
  81
  82 int kvm_arch_init_vcpu(CPUState *env)
  83 {
  84     int ret = 0;
  85
  86     if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
  87         perror("cannot init reset vcpu");
  88     }
  89
  90     return ret;
  91 }
  92
  93 void kvm_arch_reset_vcpu(CPUState *env)
  94 {
  95     /* FIXME: add code to reset vcpu. */
  96 }
  97
  98 int kvm_arch_put_registers(CPUState *env, int level)
  99 {
 100     struct kvm_regs regs;
 101     int ret;
 102     int i;
 103
 104     ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
 105     if (ret < 0) {
 106         return ret;
 107     }
 108
 109     for (i = 0; i < 16; i++) {
 110         regs.gprs[i] = env->regs[i];
 111     }
 112
 113     ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs);
 114     if (ret < 0) {
 115         return ret;
 116     }
 117
 118     env->kvm_run->psw_addr = env->psw.addr;
 119     env->kvm_run->psw_mask = env->psw.mask;
 120
 121     return ret;
 122 }
 123
 124 int kvm_arch_get_registers(CPUState *env)
 125 {
 126     int ret;
 127     struct kvm_regs regs;
 128     int i;
 129
 130     ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
 131     if (ret < 0) {
 132         return ret;
 133     }
 134
 135     for (i = 0; i < 16; i++) {
 136         env->regs[i] = regs.gprs[i];
 137     }
 138
 139     env->psw.addr = env->kvm_run->psw_addr;
 140     env->psw.mask = env->kvm_run->psw_mask;
 141
 142     return 0;
 143 }
 144
 145 int kvm_arch_insert_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
 146 {
 147     static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
 148
 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)) {
 151         return -EINVAL;
 152     }
 153     return 0;
 154 }
 155
 156 int kvm_arch_remove_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
 157 {
 158     uint8_t t[4];
 159     static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
 160
 161     if (cpu_memory_rw_debug(env, bp->pc, t, 4, 0)) {
 162         return -EINVAL;
 163     } else if (memcmp(t, diag_501, 4)) {
 164         return -EINVAL;
 165     } else if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) {
 166         return -EINVAL;
 167     }
 168
 169     return 0;
 170 }
 171
 172 void kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
 173 {
 174 }
 175
 176 void kvm_arch_post_run(CPUState *env, struct kvm_run *run)
 177 {
 178 }
 179
 180 int kvm_arch_process_async_events(CPUState *env)
 181 {
 182     return 0;
 183 }
 184
 185 static void kvm_s390_interrupt_internal(CPUState *env, int type, uint32_t parm,
 186                                         uint64_t parm64, int vm)
 187 {
 188     struct kvm_s390_interrupt kvmint;
 189     int r;
 190
 191     if (!env->kvm_state) {
 192         return;
 193     }
 194
 195     env->halted = 0;
 196     env->exception_index = -1;
 197     qemu_cpu_kick(env);
 198
 199     kvmint.type = type;
 200     kvmint.parm = parm;
 201     kvmint.parm64 = parm64;
 202
 203     if (vm) {
 204         r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint);
 205     } else {
 206         r = kvm_vcpu_ioctl(env, KVM_S390_INTERRUPT, &kvmint);
 207     }
 208
 209     if (r < 0) {
 210         fprintf(stderr, "KVM failed to inject interrupt\n");
 211         exit(1);
 212     }
 213 }
 214
 215 void kvm_s390_virtio_irq(CPUState *env, int config_change, uint64_t token)
 216 {
 217     kvm_s390_interrupt_internal(env, KVM_S390_INT_VIRTIO, config_change,
 218                                 token, 1);
 219 }
 220
 221 static void kvm_s390_interrupt(CPUState *env, int type, uint32_t code)
 222 {
 223     kvm_s390_interrupt_internal(env, type, code, 0, 0);
 224 }
 225
 226 static void enter_pgmcheck(CPUState *env, uint16_t code)
 227 {
 228     kvm_s390_interrupt(env, KVM_S390_PROGRAM_INT, code);
 229 }
 230
 231 static void setcc(CPUState *env, uint64_t cc)
 232 {
 233     env->kvm_run->psw_mask &= ~(3ul << 44);
 234     env->kvm_run->psw_mask |= (cc & 3) << 44;
 235
 236     env->psw.mask &= ~(3ul << 44);
 237     env->psw.mask |= (cc & 3) << 44;
 238 }
 239
 240 static int sclp_service_call(CPUState *env, struct kvm_run *run, uint16_t ipbh0)
 241 {
 242     uint32_t sccb;
 243     uint64_t code;
 244     int r = 0;
 245
 246     cpu_synchronize_state(env);
 247     sccb = env->regs[ipbh0 & 0xf];
 248     code = env->regs[(ipbh0 & 0xf0) >> 4];
 249
 250     dprintf("sclp(0x%x, 0x%lx)\n", sccb, code);
 251
 252     if (sccb & ~0x7ffffff8ul) {
 253         fprintf(stderr, "KVM: invalid sccb address 0x%x\n", sccb);
 254         r = -1;
 255         goto out;
 256     }
 257
 258     switch(code) {
 259         case SCLP_CMDW_READ_SCP_INFO:
 260         case SCLP_CMDW_READ_SCP_INFO_FORCED:
 261             stw_phys(sccb + SCP_MEM_CODE, ram_size >> 20);
 262             stb_phys(sccb + SCP_INCREMENT, 1);
 263             stw_phys(sccb + SCP_RESPONSE_CODE, 0x10);
 264             setcc(env, 0);
 265
 266             kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE,
 267                                         sccb & ~3, 0, 1);
 268             break;
 269         default:
 270             dprintf("KVM: invalid sclp call 0x%x / 0x%lx\n", sccb, code);
 271             r = -1;
 272             break;
 273     }
 274
 275 out:
 276     if (r < 0) {
 277         setcc(env, 3);
 278     }
 279     return 0;
 280 }
 281
 282 static int handle_priv(CPUState *env, struct kvm_run *run, uint8_t ipa1)
 283 {
 284     int r = 0;
 285     uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
 286
 287     dprintf("KVM: PRIV: %d\n", ipa1);
 288     switch (ipa1) {
 289         case PRIV_SCLP_CALL:
 290             r = sclp_service_call(env, run, ipbh0);
 291             break;
 292         default:
 293             dprintf("KVM: unknown PRIV: 0x%x\n", ipa1);
 294             r = -1;
 295             break;
 296     }
 297
 298     return r;
 299 }
 300
 301 static int handle_hypercall(CPUState *env, struct kvm_run *run)
 302 {
 303     int r;
 304
 305     cpu_synchronize_state(env);
 306     r = s390_virtio_hypercall(env);
 307
 308     return r;
 309 }
 310
 311 static int handle_diag(CPUState *env, struct kvm_run *run, int ipb_code)
 312 {
 313     int r = 0;
 314
 315     switch (ipb_code) {
 316         case DIAG_KVM_HYPERCALL:
 317             r = handle_hypercall(env, run);
 318             break;
 319         case DIAG_KVM_BREAKPOINT:
 320             sleep(10);
 321             break;
 322         default:
 323             dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code);
 324             r = -1;
 325             break;
 326     }
 327
 328     return r;
 329 }
 330
 331 static int s390_cpu_restart(CPUState *env)
 332 {
 333     kvm_s390_interrupt(env, KVM_S390_RESTART, 0);
 334     env->halted = 0;
 335     env->exception_index = -1;
 336     qemu_cpu_kick(env);
 337     dprintf("DONE: SIGP cpu restart: %p\n", env);
 338     return 0;
 339 }
 340
 341 static int s390_store_status(CPUState *env, uint32_t parameter)
 342 {
 343     /* XXX */
 344     fprintf(stderr, "XXX SIGP store status\n");
 345     return -1;
 346 }
 347
 348 static int s390_cpu_initial_reset(CPUState *env)
 349 {
 350     int i;
 351
 352     if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
 353         perror("cannot init reset vcpu");
 354     }
 355
 356     /* Manually zero out all registers */
 357     cpu_synchronize_state(env);
 358     for (i = 0; i < 16; i++) {
 359         env->regs[i] = 0;
 360     }
 361
 362     dprintf("DONE: SIGP initial reset: %p\n", env);
 363     return 0;
 364 }
 365
 366 static int handle_sigp(CPUState *env, struct kvm_run *run, uint8_t ipa1)
 367 {
 368     uint8_t order_code;
 369     uint32_t parameter;
 370     uint16_t cpu_addr;
 371     uint8_t t;
 372     int r = -1;
 373     CPUState *target_env;
 374
 375     cpu_synchronize_state(env);
 376
 377     /* get order code */
 378     order_code = run->s390_sieic.ipb >> 28;
 379     if (order_code > 0) {
 380         order_code = env->regs[order_code];
 381     }
 382     order_code += (run->s390_sieic.ipb & 0x0fff0000) >> 16;
 383
 384     /* get parameters */
 385     t = (ipa1 & 0xf0) >> 4;
 386     if (!(t % 2)) {
 387         t++;
 388     }
 389
 390     parameter = env->regs[t] & 0x7ffffe00;
 391     cpu_addr = env->regs[ipa1 & 0x0f];
 392
 393     target_env = s390_cpu_addr2state(cpu_addr);
 394     if (!target_env) {
 395         goto out;
 396     }
 397
 398     switch (order_code) {
 399         case SIGP_RESTART:
 400             r = s390_cpu_restart(target_env);
 401             break;
 402         case SIGP_STORE_STATUS_ADDR:
 403             r = s390_store_status(target_env, parameter);
 404             break;
 405         case SIGP_SET_ARCH:
 406             /* make the caller panic */
 407             return -1;
 408         case SIGP_INITIAL_CPU_RESET:
 409             r = s390_cpu_initial_reset(target_env);
 410             break;
 411         default:
 412             fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", ipa1);
 413             break;
 414     }
 415
 416 out:
 417     setcc(env, r ? 3 : 0);
 418     return 0;
 419 }
 420
 421 static int handle_instruction(CPUState *env, struct kvm_run *run)
 422 {
 423     unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
 424     uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
 425     int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;
 426     int r = -1;
 427
 428     dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb);
 429     switch (ipa0) {
 430         case IPA0_PRIV:
 431             r = handle_priv(env, run, ipa1);
 432             break;
 433         case IPA0_DIAG:
 434             r = handle_diag(env, run, ipb_code);
 435             break;
 436         case IPA0_SIGP:
 437             r = handle_sigp(env, run, ipa1);
 438             break;
 439     }
 440
 441     if (r < 0) {
 442         enter_pgmcheck(env, 0x0001);
 443     }
 444     return r;
 445 }
 446
 447 static int handle_intercept(CPUState *env)
 448 {
 449     struct kvm_run *run = env->kvm_run;
 450     int icpt_code = run->s390_sieic.icptcode;
 451     int r = 0;
 452
 453     dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code, env->kvm_run->psw_addr);
 454     switch (icpt_code) {
 455         case ICPT_INSTRUCTION:
 456             r = handle_instruction(env, run);
 457             break;
 458         case ICPT_WAITPSW:
 459             /* XXX What to do on system shutdown? */
 460             env->halted = 1;
 461             env->exception_index = EXCP_HLT;
 462             break;
 463         case ICPT_SOFT_INTERCEPT:
 464             fprintf(stderr, "KVM unimplemented icpt SOFT\n");
 465             exit(1);
 466             break;
 467         case ICPT_CPU_STOP:
 468             qemu_system_shutdown_request();
 469             break;
 470         case ICPT_IO:
 471             fprintf(stderr, "KVM unimplemented icpt IO\n");
 472             exit(1);
 473             break;
 474         default:
 475             fprintf(stderr, "Unknown intercept code: %d\n", icpt_code);
 476             exit(1);
 477             break;
 478     }
 479
 480     return r;
 481 }
 482
 483 int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run)
 484 {
 485     int ret = 0;
 486
 487     switch (run->exit_reason) {
 488         case KVM_EXIT_S390_SIEIC:
 489             ret = handle_intercept(env);
 490             break;
 491         case KVM_EXIT_S390_RESET:
 492             fprintf(stderr, "RESET not implemented\n");
 493             exit(1);
 494             break;
 495         default:
 496             fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
 497             break;
 498     }
 499
 500     if (ret == 0) {
 501         ret = EXCP_INTERRUPT;
 502     } else if (ret > 0) {
 503         ret = 0;
 504     }
 505     return ret;
 506 }
 507
 508 bool kvm_arch_stop_on_emulation_error(CPUState *env)
 509 {
 510     return true;
 511 }
 512
 513 int kvm_arch_on_sigbus_vcpu(CPUState *env, int code, void *addr)
 514 {
 515     return 1;
 516 }
 517
 518 int kvm_arch_on_sigbus(int code, void *addr)
 519 {
 520     return 1;
 521 }