target-s390x/kvm.c

   1 /*
   2  * QEMU S390x KVM implementation
   3  *
   4  * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
   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 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 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 kvm_sclp_service_call(CPUState *env, struct kvm_run *run,
 241                                  uint16_t ipbh0)
 242 {
 243     uint32_t sccb;
 244     uint64_t code;
 245     int r = 0;
 246
 247     cpu_synchronize_state(env);
 248     sccb = env->regs[ipbh0 & 0xf];
 249     code = env->regs[(ipbh0 & 0xf0) >> 4];
 250
 251     dprintf("sclp(0x%x, 0x%lx)\n", sccb, code);
 252
 253     if (sccb & ~0x7ffffff8ul) {
 254         fprintf(stderr, "KVM: invalid sccb address 0x%x\n", sccb);
 255         r = -1;
 256         goto out;
 257     }
 258
 259     switch(code) {
 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);
 265             setcc(env, 0);
 266
 267             kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE,
 268                                         sccb & ~3, 0, 1);
 269             break;
 270         default:
 271             dprintf("KVM: invalid sclp call 0x%x / 0x%lx\n", sccb, code);
 272             r = -1;
 273             break;
 274     }
 275
 276 out:
 277     if (r < 0) {
 278         setcc(env, 3);
 279     }
 280     return 0;
 281 }
 282
 283 static int handle_priv(CPUState *env, struct kvm_run *run, uint8_t ipa1)
 284 {
 285     int r = 0;
 286     uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
 287
 288     dprintf("KVM: PRIV: %d\n", ipa1);
 289     switch (ipa1) {
 290         case PRIV_SCLP_CALL:
 291             r = kvm_sclp_service_call(env, run, ipbh0);
 292             break;
 293         default:
 294             dprintf("KVM: unknown PRIV: 0x%x\n", ipa1);
 295             r = -1;
 296             break;
 297     }
 298
 299     return r;
 300 }
 301
 302 static int handle_hypercall(CPUState *env, struct kvm_run *run)
 303 {
 304     cpu_synchronize_state(env);
 305     env->regs[2] = s390_virtio_hypercall(env, env->regs[2], env->regs[1]);
 306
 307     return 0;
 308 }
 309
 310 static int handle_diag(CPUState *env, struct kvm_run *run, int ipb_code)
 311 {
 312     int r = 0;
 313
 314     switch (ipb_code) {
 315         case DIAG_KVM_HYPERCALL:
 316             r = handle_hypercall(env, run);
 317             break;
 318         case DIAG_KVM_BREAKPOINT:
 319             sleep(10);
 320             break;
 321         default:
 322             dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code);
 323             r = -1;
 324             break;
 325     }
 326
 327     return r;
 328 }
 329
 330 static int s390_cpu_restart(CPUState *env)
 331 {
 332     kvm_s390_interrupt(env, KVM_S390_RESTART, 0);
 333     env->halted = 0;
 334     env->exception_index = -1;
 335     qemu_cpu_kick(env);
 336     dprintf("DONE: SIGP cpu restart: %p\n", env);
 337     return 0;
 338 }
 339
 340 static int s390_store_status(CPUState *env, uint32_t parameter)
 341 {
 342     /* XXX */
 343     fprintf(stderr, "XXX SIGP store status\n");
 344     return -1;
 345 }
 346
 347 static int s390_cpu_initial_reset(CPUState *env)
 348 {
 349     int i;
 350
 351     if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
 352         perror("cannot init reset vcpu");
 353     }
 354
 355     /* Manually zero out all registers */
 356     cpu_synchronize_state(env);
 357     for (i = 0; i < 16; i++) {
 358         env->regs[i] = 0;
 359     }
 360
 361     dprintf("DONE: SIGP initial reset: %p\n", env);
 362     return 0;
 363 }
 364
 365 static int handle_sigp(CPUState *env, struct kvm_run *run, uint8_t ipa1)
 366 {
 367     uint8_t order_code;
 368     uint32_t parameter;
 369     uint16_t cpu_addr;
 370     uint8_t t;
 371     int r = -1;
 372     CPUState *target_env;
 373
 374     cpu_synchronize_state(env);
 375
 376     /* get order code */
 377     order_code = run->s390_sieic.ipb >> 28;
 378     if (order_code > 0) {
 379         order_code = env->regs[order_code];
 380     }
 381     order_code += (run->s390_sieic.ipb & 0x0fff0000) >> 16;
 382
 383     /* get parameters */
 384     t = (ipa1 & 0xf0) >> 4;
 385     if (!(t % 2)) {
 386         t++;
 387     }
 388
 389     parameter = env->regs[t] & 0x7ffffe00;
 390     cpu_addr = env->regs[ipa1 & 0x0f];
 391
 392     target_env = s390_cpu_addr2state(cpu_addr);
 393     if (!target_env) {
 394         goto out;
 395     }
 396
 397     switch (order_code) {
 398         case SIGP_RESTART:
 399             r = s390_cpu_restart(target_env);
 400             break;
 401         case SIGP_STORE_STATUS_ADDR:
 402             r = s390_store_status(target_env, parameter);
 403             break;
 404         case SIGP_SET_ARCH:
 405             /* make the caller panic */
 406             return -1;
 407         case SIGP_INITIAL_CPU_RESET:
 408             r = s390_cpu_initial_reset(target_env);
 409             break;
 410         default:
 411             fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", ipa1);
 412             break;
 413     }
 414
 415 out:
 416     setcc(env, r ? 3 : 0);
 417     return 0;
 418 }
 419
 420 static int handle_instruction(CPUState *env, struct kvm_run *run)
 421 {
 422     unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
 423     uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
 424     int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;
 425     int r = -1;
 426
 427     dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb);
 428     switch (ipa0) {
 429         case IPA0_PRIV:
 430             r = handle_priv(env, run, ipa1);
 431             break;
 432         case IPA0_DIAG:
 433             r = handle_diag(env, run, ipb_code);
 434             break;
 435         case IPA0_SIGP:
 436             r = handle_sigp(env, run, ipa1);
 437             break;
 438     }
 439
 440     if (r < 0) {
 441         enter_pgmcheck(env, 0x0001);
 442     }
 443     return 0;
 444 }
 445
 446 static int handle_intercept(CPUState *env)
 447 {
 448     struct kvm_run *run = env->kvm_run;
 449     int icpt_code = run->s390_sieic.icptcode;
 450     int r = 0;
 451
 452     dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code, env->kvm_run->psw_addr);
 453     switch (icpt_code) {
 454         case ICPT_INSTRUCTION:
 455             r = handle_instruction(env, run);
 456             break;
 457         case ICPT_WAITPSW:
 458             /* XXX What to do on system shutdown? */
 459             env->halted = 1;
 460             env->exception_index = EXCP_HLT;
 461             break;
 462         case ICPT_SOFT_INTERCEPT:
 463             fprintf(stderr, "KVM unimplemented icpt SOFT\n");
 464             exit(1);
 465             break;
 466         case ICPT_CPU_STOP:
 467             qemu_system_shutdown_request();
 468             break;
 469         case ICPT_IO:
 470             fprintf(stderr, "KVM unimplemented icpt IO\n");
 471             exit(1);
 472             break;
 473         default:
 474             fprintf(stderr, "Unknown intercept code: %d\n", icpt_code);
 475             exit(1);
 476             break;
 477     }
 478
 479     return r;
 480 }
 481
 482 int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run)
 483 {
 484     int ret = 0;
 485
 486     switch (run->exit_reason) {
 487         case KVM_EXIT_S390_SIEIC:
 488             ret = handle_intercept(env);
 489             break;
 490         case KVM_EXIT_S390_RESET:
 491             fprintf(stderr, "RESET not implemented\n");
 492             exit(1);
 493             break;
 494         default:
 495             fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
 496             break;
 497     }
 498
 499     if (ret == 0) {
 500         ret = EXCP_INTERRUPT;
 501     } else if (ret > 0) {
 502         ret = 0;
 503     }
 504     return ret;
 505 }
 506
 507 bool kvm_arch_stop_on_emulation_error(CPUState *env)
 508 {
 509     return true;
 510 }
 511
 512 int kvm_arch_on_sigbus_vcpu(CPUState *env, int code, void *addr)
 513 {
 514     return 1;
 515 }
 516
 517 int kvm_arch_on_sigbus(int code, void *addr)
 518 {
 519     return 1;
 520 }