target-s390x/kvm.c

   1 /*
   2  * QEMU S390x KVM implementation
   3  *
   4  * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
   5  * Copyright IBM Corp. 2012
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * Contributions after 2012-10-29 are licensed under the terms of the
  18  * GNU GPL, version 2 or (at your option) any later version.
  19  *
  20  * You should have received a copy of the GNU (Lesser) General Public
  21  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #include <sys/types.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/mman.h>
  27
  28 #include <linux/kvm.h>
  29 #include <asm/ptrace.h>
  30
  31 #include "qemu-common.h"
  32 #include "qemu/timer.h"
  33 #include "sysemu/sysemu.h"
  34 #include "sysemu/kvm.h"
  35 #include "hw/hw.h"
  36 #include "cpu.h"
  37 #include "sysemu/device_tree.h"
  38 #include "qapi/qmp/qjson.h"
  39 #include "monitor/monitor.h"
  40 #include "exec/gdbstub.h"
  41 #include "trace.h"
  42 #include "qapi-event.h"
  43
  44 /* #define DEBUG_KVM */
  45
  46 #ifdef DEBUG_KVM
  47 #define DPRINTF(fmt, ...) \
  48     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
  49 #else
  50 #define DPRINTF(fmt, ...) \
  51     do { } while (0)
  52 #endif
  53
  54 #define IPA0_DIAG                       0x8300
  55 #define IPA0_SIGP                       0xae00
  56 #define IPA0_B2                         0xb200
  57 #define IPA0_B9                         0xb900
  58 #define IPA0_EB                         0xeb00
  59
  60 #define PRIV_B2_SCLP_CALL               0x20
  61 #define PRIV_B2_CSCH                    0x30
  62 #define PRIV_B2_HSCH                    0x31
  63 #define PRIV_B2_MSCH                    0x32
  64 #define PRIV_B2_SSCH                    0x33
  65 #define PRIV_B2_STSCH                   0x34
  66 #define PRIV_B2_TSCH                    0x35
  67 #define PRIV_B2_TPI                     0x36
  68 #define PRIV_B2_SAL                     0x37
  69 #define PRIV_B2_RSCH                    0x38
  70 #define PRIV_B2_STCRW                   0x39
  71 #define PRIV_B2_STCPS                   0x3a
  72 #define PRIV_B2_RCHP                    0x3b
  73 #define PRIV_B2_SCHM                    0x3c
  74 #define PRIV_B2_CHSC                    0x5f
  75 #define PRIV_B2_SIGA                    0x74
  76 #define PRIV_B2_XSCH                    0x76
  77
  78 #define PRIV_EB_SQBS                    0x8a
  79
  80 #define PRIV_B9_EQBS                    0x9c
  81
  82 #define DIAG_IPL                        0x308
  83 #define DIAG_KVM_HYPERCALL              0x500
  84 #define DIAG_KVM_BREAKPOINT             0x501
  85
  86 #define ICPT_INSTRUCTION                0x04
  87 #define ICPT_PROGRAM                    0x08
  88 #define ICPT_EXT_INT                    0x14
  89 #define ICPT_WAITPSW                    0x1c
  90 #define ICPT_SOFT_INTERCEPT             0x24
  91 #define ICPT_CPU_STOP                   0x28
  92 #define ICPT_IO                         0x40
  93
  94 static CPUWatchpoint hw_watchpoint;
  95 /*
  96  * We don't use a list because this structure is also used to transmit the
  97  * hardware breakpoints to the kernel.
  98  */
  99 static struct kvm_hw_breakpoint *hw_breakpoints;
 100 static int nb_hw_breakpoints;
 101
 102 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
 103     KVM_CAP_LAST_INFO
 104 };
 105
 106 static int cap_sync_regs;
 107 static int cap_async_pf;
 108
 109 static void *legacy_s390_alloc(size_t size);
 110
 111 static int kvm_s390_check_clear_cmma(KVMState *s)
 112 {
 113     struct kvm_device_attr attr = {
 114         .group = KVM_S390_VM_MEM_CTRL,
 115         .attr = KVM_S390_VM_MEM_CLR_CMMA,
 116     };
 117
 118     return kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attr);
 119 }
 120
 121 static int kvm_s390_check_enable_cmma(KVMState *s)
 122 {
 123     struct kvm_device_attr attr = {
 124         .group = KVM_S390_VM_MEM_CTRL,
 125         .attr = KVM_S390_VM_MEM_ENABLE_CMMA,
 126     };
 127
 128     return kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attr);
 129 }
 130
 131 void kvm_s390_clear_cmma_callback(void *opaque)
 132 {
 133     int rc;
 134     KVMState *s = opaque;
 135     struct kvm_device_attr attr = {
 136         .group = KVM_S390_VM_MEM_CTRL,
 137         .attr = KVM_S390_VM_MEM_CLR_CMMA,
 138     };
 139
 140     rc = kvm_vm_ioctl(s, KVM_SET_DEVICE_ATTR, &attr);
 141     trace_kvm_clear_cmma(rc);
 142 }
 143
 144 static void kvm_s390_enable_cmma(KVMState *s)
 145 {
 146     int rc;
 147     struct kvm_device_attr attr = {
 148         .group = KVM_S390_VM_MEM_CTRL,
 149         .attr = KVM_S390_VM_MEM_ENABLE_CMMA,
 150     };
 151
 152     if (kvm_s390_check_enable_cmma(s) || kvm_s390_check_clear_cmma(s)) {
 153         return;
 154     }
 155
 156     rc = kvm_vm_ioctl(s, KVM_SET_DEVICE_ATTR, &attr);
 157     if (!rc) {
 158         qemu_register_reset(kvm_s390_clear_cmma_callback, s);
 159     }
 160     trace_kvm_enable_cmma(rc);
 161 }
 162
 163 int kvm_arch_init(KVMState *s)
 164 {
 165     cap_sync_regs = kvm_check_extension(s, KVM_CAP_SYNC_REGS);
 166     cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF);
 167
 168     if (kvm_check_extension(s, KVM_CAP_VM_ATTRIBUTES)) {
 169         kvm_s390_enable_cmma(s);
 170     }
 171
 172     if (!kvm_check_extension(s, KVM_CAP_S390_GMAP)
 173         || !kvm_check_extension(s, KVM_CAP_S390_COW)) {
 174         phys_mem_set_alloc(legacy_s390_alloc);
 175     }
 176     return 0;
 177 }
 178
 179 unsigned long kvm_arch_vcpu_id(CPUState *cpu)
 180 {
 181     return cpu->cpu_index;
 182 }
 183
 184 int kvm_arch_init_vcpu(CPUState *cpu)
 185 {
 186     /* nothing todo yet */
 187     return 0;
 188 }
 189
 190 void kvm_s390_reset_vcpu(S390CPU *cpu)
 191 {
 192     CPUState *cs = CPU(cpu);
 193
 194     /* The initial reset call is needed here to reset in-kernel
 195      * vcpu data that we can't access directly from QEMU
 196      * (i.e. with older kernels which don't support sync_regs/ONE_REG).
 197      * Before this ioctl cpu_synchronize_state() is called in common kvm
 198      * code (kvm-all) */
 199     if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL)) {
 200         perror("Can't reset vcpu\n");
 201     }
 202 }
 203
 204 int kvm_arch_put_registers(CPUState *cs, int level)
 205 {
 206     S390CPU *cpu = S390_CPU(cs);
 207     CPUS390XState *env = &cpu->env;
 208     struct kvm_sregs sregs;
 209     struct kvm_regs regs;
 210     int r;
 211     int i;
 212
 213     /* always save the PSW  and the GPRS*/
 214     cs->kvm_run->psw_addr = env->psw.addr;
 215     cs->kvm_run->psw_mask = env->psw.mask;
 216
 217     if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_GPRS) {
 218         for (i = 0; i < 16; i++) {
 219             cs->kvm_run->s.regs.gprs[i] = env->regs[i];
 220             cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_GPRS;
 221         }
 222     } else {
 223         for (i = 0; i < 16; i++) {
 224             regs.gprs[i] = env->regs[i];
 225         }
 226         r = kvm_vcpu_ioctl(cs, KVM_SET_REGS, &regs);
 227         if (r < 0) {
 228             return r;
 229         }
 230     }
 231
 232     /* Do we need to save more than that? */
 233     if (level == KVM_PUT_RUNTIME_STATE) {
 234         return 0;
 235     }
 236
 237     /*
 238      * These ONE_REGS are not protected by a capability. As they are only
 239      * necessary for migration we just trace a possible error, but don't
 240      * return with an error return code.
 241      */
 242     kvm_set_one_reg(cs, KVM_REG_S390_CPU_TIMER, &env->cputm);
 243     kvm_set_one_reg(cs, KVM_REG_S390_CLOCK_COMP, &env->ckc);
 244     kvm_set_one_reg(cs, KVM_REG_S390_TODPR, &env->todpr);
 245     kvm_set_one_reg(cs, KVM_REG_S390_GBEA, &env->gbea);
 246     kvm_set_one_reg(cs, KVM_REG_S390_PP, &env->pp);
 247
 248     if (cap_async_pf) {
 249         r = kvm_set_one_reg(cs, KVM_REG_S390_PFTOKEN, &env->pfault_token);
 250         if (r < 0) {
 251             return r;
 252         }
 253         r = kvm_set_one_reg(cs, KVM_REG_S390_PFCOMPARE, &env->pfault_compare);
 254         if (r < 0) {
 255             return r;
 256         }
 257         r = kvm_set_one_reg(cs, KVM_REG_S390_PFSELECT, &env->pfault_select);
 258         if (r < 0) {
 259             return r;
 260         }
 261     }
 262
 263     if (cap_sync_regs &&
 264         cs->kvm_run->kvm_valid_regs & KVM_SYNC_ACRS &&
 265         cs->kvm_run->kvm_valid_regs & KVM_SYNC_CRS) {
 266         for (i = 0; i < 16; i++) {
 267             cs->kvm_run->s.regs.acrs[i] = env->aregs[i];
 268             cs->kvm_run->s.regs.crs[i] = env->cregs[i];
 269         }
 270         cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_ACRS;
 271         cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_CRS;
 272     } else {
 273         for (i = 0; i < 16; i++) {
 274             sregs.acrs[i] = env->aregs[i];
 275             sregs.crs[i] = env->cregs[i];
 276         }
 277         r = kvm_vcpu_ioctl(cs, KVM_SET_SREGS, &sregs);
 278         if (r < 0) {
 279             return r;
 280         }
 281     }
 282
 283     /* Finally the prefix */
 284     if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_PREFIX) {
 285         cs->kvm_run->s.regs.prefix = env->psa;
 286         cs->kvm_run->kvm_dirty_regs |= KVM_SYNC_PREFIX;
 287     } else {
 288         /* prefix is only supported via sync regs */
 289     }
 290     return 0;
 291 }
 292
 293 int kvm_arch_get_registers(CPUState *cs)
 294 {
 295     S390CPU *cpu = S390_CPU(cs);
 296     CPUS390XState *env = &cpu->env;
 297     struct kvm_sregs sregs;
 298     struct kvm_regs regs;
 299     int i, r;
 300
 301     /* get the PSW */
 302     env->psw.addr = cs->kvm_run->psw_addr;
 303     env->psw.mask = cs->kvm_run->psw_mask;
 304
 305     /* the GPRS */
 306     if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_GPRS) {
 307         for (i = 0; i < 16; i++) {
 308             env->regs[i] = cs->kvm_run->s.regs.gprs[i];
 309         }
 310     } else {
 311         r = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
 312         if (r < 0) {
 313             return r;
 314         }
 315          for (i = 0; i < 16; i++) {
 316             env->regs[i] = regs.gprs[i];
 317         }
 318     }
 319
 320     /* The ACRS and CRS */
 321     if (cap_sync_regs &&
 322         cs->kvm_run->kvm_valid_regs & KVM_SYNC_ACRS &&
 323         cs->kvm_run->kvm_valid_regs & KVM_SYNC_CRS) {
 324         for (i = 0; i < 16; i++) {
 325             env->aregs[i] = cs->kvm_run->s.regs.acrs[i];
 326             env->cregs[i] = cs->kvm_run->s.regs.crs[i];
 327         }
 328     } else {
 329         r = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
 330         if (r < 0) {
 331             return r;
 332         }
 333          for (i = 0; i < 16; i++) {
 334             env->aregs[i] = sregs.acrs[i];
 335             env->cregs[i] = sregs.crs[i];
 336         }
 337     }
 338
 339     /* The prefix */
 340     if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_PREFIX) {
 341         env->psa = cs->kvm_run->s.regs.prefix;
 342     }
 343
 344     /*
 345      * These ONE_REGS are not protected by a capability. As they are only
 346      * necessary for migration we just trace a possible error, but don't
 347      * return with an error return code.
 348      */
 349     kvm_get_one_reg(cs, KVM_REG_S390_CPU_TIMER, &env->cputm);
 350     kvm_get_one_reg(cs, KVM_REG_S390_CLOCK_COMP, &env->ckc);
 351     kvm_get_one_reg(cs, KVM_REG_S390_TODPR, &env->todpr);
 352     kvm_get_one_reg(cs, KVM_REG_S390_GBEA, &env->gbea);
 353     kvm_get_one_reg(cs, KVM_REG_S390_PP, &env->pp);
 354
 355     if (cap_async_pf) {
 356         r = kvm_get_one_reg(cs, KVM_REG_S390_PFTOKEN, &env->pfault_token);
 357         if (r < 0) {
 358             return r;
 359         }
 360         r = kvm_get_one_reg(cs, KVM_REG_S390_PFCOMPARE, &env->pfault_compare);
 361         if (r < 0) {
 362             return r;
 363         }
 364         r = kvm_get_one_reg(cs, KVM_REG_S390_PFSELECT, &env->pfault_select);
 365         if (r < 0) {
 366             return r;
 367         }
 368     }
 369
 370     return 0;
 371 }
 372
 373 /*
 374  * Legacy layout for s390:
 375  * Older S390 KVM requires the topmost vma of the RAM to be
 376  * smaller than an system defined value, which is at least 256GB.
 377  * Larger systems have larger values. We put the guest between
 378  * the end of data segment (system break) and this value. We
 379  * use 32GB as a base to have enough room for the system break
 380  * to grow. We also have to use MAP parameters that avoid
 381  * read-only mapping of guest pages.
 382  */
 383 static void *legacy_s390_alloc(size_t size)
 384 {
 385     void *mem;
 386
 387     mem = mmap((void *) 0x800000000ULL, size,
 388                PROT_EXEC|PROT_READ|PROT_WRITE,
 389                MAP_SHARED | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
 390     return mem == MAP_FAILED ? NULL : mem;
 391 }
 392
 393 /* DIAG 501 is used for sw breakpoints */
 394 static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
 395
 396 int kvm_arch_insert_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
 397 {
 398
 399     if (cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn,
 400                             sizeof(diag_501), 0) ||
 401         cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)diag_501,
 402                             sizeof(diag_501), 1)) {
 403         return -EINVAL;
 404     }
 405     return 0;
 406 }
 407
 408 int kvm_arch_remove_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
 409 {
 410     uint8_t t[sizeof(diag_501)];
 411
 412     if (cpu_memory_rw_debug(cs, bp->pc, t, sizeof(diag_501), 0)) {
 413         return -EINVAL;
 414     } else if (memcmp(t, diag_501, sizeof(diag_501))) {
 415         return -EINVAL;
 416     } else if (cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn,
 417                                    sizeof(diag_501), 1)) {
 418         return -EINVAL;
 419     }
 420
 421     return 0;
 422 }
 423
 424 static struct kvm_hw_breakpoint *find_hw_breakpoint(target_ulong addr,
 425                                                     int len, int type)
 426 {
 427     int n;
 428
 429     for (n = 0; n < nb_hw_breakpoints; n++) {
 430         if (hw_breakpoints[n].addr == addr && hw_breakpoints[n].type == type &&
 431             (hw_breakpoints[n].len == len || len == -1)) {
 432             return &hw_breakpoints[n];
 433         }
 434     }
 435
 436     return NULL;
 437 }
 438
 439 static int insert_hw_breakpoint(target_ulong addr, int len, int type)
 440 {
 441     int size;
 442
 443     if (find_hw_breakpoint(addr, len, type)) {
 444         return -EEXIST;
 445     }
 446
 447     size = (nb_hw_breakpoints + 1) * sizeof(struct kvm_hw_breakpoint);
 448
 449     if (!hw_breakpoints) {
 450         nb_hw_breakpoints = 0;
 451         hw_breakpoints = (struct kvm_hw_breakpoint *)g_try_malloc(size);
 452     } else {
 453         hw_breakpoints =
 454             (struct kvm_hw_breakpoint *)g_try_realloc(hw_breakpoints, size);
 455     }
 456
 457     if (!hw_breakpoints) {
 458         nb_hw_breakpoints = 0;
 459         return -ENOMEM;
 460     }
 461
 462     hw_breakpoints[nb_hw_breakpoints].addr = addr;
 463     hw_breakpoints[nb_hw_breakpoints].len = len;
 464     hw_breakpoints[nb_hw_breakpoints].type = type;
 465
 466     nb_hw_breakpoints++;
 467
 468     return 0;
 469 }
 470
 471 int kvm_arch_insert_hw_breakpoint(target_ulong addr,
 472                                   target_ulong len, int type)
 473 {
 474     switch (type) {
 475     case GDB_BREAKPOINT_HW:
 476         type = KVM_HW_BP;
 477         break;
 478     case GDB_WATCHPOINT_WRITE:
 479         if (len < 1) {
 480             return -EINVAL;
 481         }
 482         type = KVM_HW_WP_WRITE;
 483         break;
 484     default:
 485         return -ENOSYS;
 486     }
 487     return insert_hw_breakpoint(addr, len, type);
 488 }
 489
 490 int kvm_arch_remove_hw_breakpoint(target_ulong addr,
 491                                   target_ulong len, int type)
 492 {
 493     int size;
 494     struct kvm_hw_breakpoint *bp = find_hw_breakpoint(addr, len, type);
 495
 496     if (bp == NULL) {
 497         return -ENOENT;
 498     }
 499
 500     nb_hw_breakpoints--;
 501     if (nb_hw_breakpoints > 0) {
 502         /*
 503          * In order to trim the array, move the last element to the position to
 504          * be removed - if necessary.
 505          */
 506         if (bp != &hw_breakpoints[nb_hw_breakpoints]) {
 507             *bp = hw_breakpoints[nb_hw_breakpoints];
 508         }
 509         size = nb_hw_breakpoints * sizeof(struct kvm_hw_breakpoint);
 510         hw_breakpoints =
 511              (struct kvm_hw_breakpoint *)g_realloc(hw_breakpoints, size);
 512     } else {
 513         g_free(hw_breakpoints);
 514         hw_breakpoints = NULL;
 515     }
 516
 517     return 0;
 518 }
 519
 520 void kvm_arch_remove_all_hw_breakpoints(void)
 521 {
 522     nb_hw_breakpoints = 0;
 523     g_free(hw_breakpoints);
 524     hw_breakpoints = NULL;
 525 }
 526
 527 void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg)
 528 {
 529     int i;
 530
 531     if (nb_hw_breakpoints > 0) {
 532         dbg->arch.nr_hw_bp = nb_hw_breakpoints;
 533         dbg->arch.hw_bp = hw_breakpoints;
 534
 535         for (i = 0; i < nb_hw_breakpoints; ++i) {
 536             hw_breakpoints[i].phys_addr = s390_cpu_get_phys_addr_debug(cpu,
 537                                                        hw_breakpoints[i].addr);
 538         }
 539         dbg->control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_HW_BP;
 540     } else {
 541         dbg->arch.nr_hw_bp = 0;
 542         dbg->arch.hw_bp = NULL;
 543     }
 544 }
 545
 546 void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
 547 {
 548 }
 549
 550 void kvm_arch_post_run(CPUState *cpu, struct kvm_run *run)
 551 {
 552 }
 553
 554 int kvm_arch_process_async_events(CPUState *cs)
 555 {
 556     return cs->halted;
 557 }
 558
 559 static int s390_kvm_irq_to_interrupt(struct kvm_s390_irq *irq,
 560                                      struct kvm_s390_interrupt *interrupt)
 561 {
 562     int r = 0;
 563
 564     interrupt->type = irq->type;
 565     switch (irq->type) {
 566     case KVM_S390_INT_VIRTIO:
 567         interrupt->parm = irq->u.ext.ext_params;
 568         /* fall through */
 569     case KVM_S390_INT_PFAULT_INIT:
 570     case KVM_S390_INT_PFAULT_DONE:
 571         interrupt->parm64 = irq->u.ext.ext_params2;
 572         break;
 573     case KVM_S390_PROGRAM_INT:
 574         interrupt->parm = irq->u.pgm.code;
 575         break;
 576     case KVM_S390_SIGP_SET_PREFIX:
 577         interrupt->parm = irq->u.prefix.address;
 578         break;
 579     case KVM_S390_INT_SERVICE:
 580         interrupt->parm = irq->u.ext.ext_params;
 581         break;
 582     case KVM_S390_MCHK:
 583         interrupt->parm = irq->u.mchk.cr14;
 584         interrupt->parm64 = irq->u.mchk.mcic;
 585         break;
 586     case KVM_S390_INT_EXTERNAL_CALL:
 587         interrupt->parm = irq->u.extcall.code;
 588         break;
 589     case KVM_S390_INT_EMERGENCY:
 590         interrupt->parm = irq->u.emerg.code;
 591         break;
 592     case KVM_S390_SIGP_STOP:
 593     case KVM_S390_RESTART:
 594         break; /* These types have no parameters */
 595     case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX:
 596         interrupt->parm = irq->u.io.subchannel_id << 16;
 597         interrupt->parm |= irq->u.io.subchannel_nr;
 598         interrupt->parm64 = (uint64_t)irq->u.io.io_int_parm << 32;
 599         interrupt->parm64 |= irq->u.io.io_int_word;
 600         break;
 601     default:
 602         r = -EINVAL;
 603         break;
 604     }
 605     return r;
 606 }
 607
 608 void kvm_s390_vcpu_interrupt(S390CPU *cpu, struct kvm_s390_irq *irq)
 609 {
 610     struct kvm_s390_interrupt kvmint = {};
 611     CPUState *cs = CPU(cpu);
 612     int r;
 613
 614     r = s390_kvm_irq_to_interrupt(irq, &kvmint);
 615     if (r < 0) {
 616         fprintf(stderr, "%s called with bogus interrupt\n", __func__);
 617         exit(1);
 618     }
 619
 620     r = kvm_vcpu_ioctl(cs, KVM_S390_INTERRUPT, &kvmint);
 621     if (r < 0) {
 622         fprintf(stderr, "KVM failed to inject interrupt\n");
 623         exit(1);
 624     }
 625 }
 626
 627 static void __kvm_s390_floating_interrupt(struct kvm_s390_irq *irq)
 628 {
 629     struct kvm_s390_interrupt kvmint = {};
 630     int r;
 631
 632     r = s390_kvm_irq_to_interrupt(irq, &kvmint);
 633     if (r < 0) {
 634         fprintf(stderr, "%s called with bogus interrupt\n", __func__);
 635         exit(1);
 636     }
 637
 638     r = kvm_vm_ioctl(kvm_state, KVM_S390_INTERRUPT, &kvmint);
 639     if (r < 0) {
 640         fprintf(stderr, "KVM failed to inject interrupt\n");
 641         exit(1);
 642     }
 643 }
 644
 645 void kvm_s390_floating_interrupt(struct kvm_s390_irq *irq)
 646 {
 647     static bool use_flic = true;
 648     int r;
 649
 650     if (use_flic) {
 651         r = kvm_s390_inject_flic(irq);
 652         if (r == -ENOSYS) {
 653             use_flic = false;
 654         }
 655         if (!r) {
 656             return;
 657         }
 658     }
 659     __kvm_s390_floating_interrupt(irq);
 660 }
 661
 662 void kvm_s390_virtio_irq(int config_change, uint64_t token)
 663 {
 664     struct kvm_s390_irq irq = {
 665         .type = KVM_S390_INT_VIRTIO,
 666         .u.ext.ext_params = config_change,
 667         .u.ext.ext_params2 = token,
 668     };
 669
 670     kvm_s390_floating_interrupt(&irq);
 671 }
 672
 673 void kvm_s390_service_interrupt(uint32_t parm)
 674 {
 675     struct kvm_s390_irq irq = {
 676         .type = KVM_S390_INT_SERVICE,
 677         .u.ext.ext_params = parm,
 678     };
 679
 680     kvm_s390_floating_interrupt(&irq);
 681 }
 682
 683 static void enter_pgmcheck(S390CPU *cpu, uint16_t code)
 684 {
 685     struct kvm_s390_irq irq = {
 686         .type = KVM_S390_PROGRAM_INT,
 687         .u.pgm.code = code,
 688     };
 689
 690     kvm_s390_vcpu_interrupt(cpu, &irq);
 691 }
 692
 693 static int kvm_sclp_service_call(S390CPU *cpu, struct kvm_run *run,
 694                                  uint16_t ipbh0)
 695 {
 696     CPUS390XState *env = &cpu->env;
 697     uint64_t sccb;
 698     uint32_t code;
 699     int r = 0;
 700
 701     cpu_synchronize_state(CPU(cpu));
 702     sccb = env->regs[ipbh0 & 0xf];
 703     code = env->regs[(ipbh0 & 0xf0) >> 4];
 704
 705     r = sclp_service_call(env, sccb, code);
 706     if (r < 0) {
 707         enter_pgmcheck(cpu, -r);
 708     } else {
 709         setcc(cpu, r);
 710     }
 711
 712     return 0;
 713 }
 714
 715 static int handle_b2(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
 716 {
 717     CPUS390XState *env = &cpu->env;
 718     int rc = 0;
 719     uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
 720
 721     cpu_synchronize_state(CPU(cpu));
 722
 723     switch (ipa1) {
 724     case PRIV_B2_XSCH:
 725         ioinst_handle_xsch(cpu, env->regs[1]);
 726         break;
 727     case PRIV_B2_CSCH:
 728         ioinst_handle_csch(cpu, env->regs[1]);
 729         break;
 730     case PRIV_B2_HSCH:
 731         ioinst_handle_hsch(cpu, env->regs[1]);
 732         break;
 733     case PRIV_B2_MSCH:
 734         ioinst_handle_msch(cpu, env->regs[1], run->s390_sieic.ipb);
 735         break;
 736     case PRIV_B2_SSCH:
 737         ioinst_handle_ssch(cpu, env->regs[1], run->s390_sieic.ipb);
 738         break;
 739     case PRIV_B2_STCRW:
 740         ioinst_handle_stcrw(cpu, run->s390_sieic.ipb);
 741         break;
 742     case PRIV_B2_STSCH:
 743         ioinst_handle_stsch(cpu, env->regs[1], run->s390_sieic.ipb);
 744         break;
 745     case PRIV_B2_TSCH:
 746         /* We should only get tsch via KVM_EXIT_S390_TSCH. */
 747         fprintf(stderr, "Spurious tsch intercept\n");
 748         break;
 749     case PRIV_B2_CHSC:
 750         ioinst_handle_chsc(cpu, run->s390_sieic.ipb);
 751         break;
 752     case PRIV_B2_TPI:
 753         /* This should have been handled by kvm already. */
 754         fprintf(stderr, "Spurious tpi intercept\n");
 755         break;
 756     case PRIV_B2_SCHM:
 757         ioinst_handle_schm(cpu, env->regs[1], env->regs[2],
 758                            run->s390_sieic.ipb);
 759         break;
 760     case PRIV_B2_RSCH:
 761         ioinst_handle_rsch(cpu, env->regs[1]);
 762         break;
 763     case PRIV_B2_RCHP:
 764         ioinst_handle_rchp(cpu, env->regs[1]);
 765         break;
 766     case PRIV_B2_STCPS:
 767         /* We do not provide this instruction, it is suppressed. */
 768         break;
 769     case PRIV_B2_SAL:
 770         ioinst_handle_sal(cpu, env->regs[1]);
 771         break;
 772     case PRIV_B2_SIGA:
 773         /* Not provided, set CC = 3 for subchannel not operational */
 774         setcc(cpu, 3);
 775         break;
 776     case PRIV_B2_SCLP_CALL:
 777         rc = kvm_sclp_service_call(cpu, run, ipbh0);
 778         break;
 779     default:
 780         rc = -1;
 781         DPRINTF("KVM: unhandled PRIV: 0xb2%x\n", ipa1);
 782         break;
 783     }
 784
 785     return rc;
 786 }
 787
 788 static int handle_b9(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
 789 {
 790     int r = 0;
 791
 792     switch (ipa1) {
 793     case PRIV_B9_EQBS:
 794         /* just inject exception */
 795         r = -1;
 796         break;
 797     default:
 798         r = -1;
 799         DPRINTF("KVM: unhandled PRIV: 0xb9%x\n", ipa1);
 800         break;
 801     }
 802
 803     return r;
 804 }
 805
 806 static int handle_eb(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
 807 {
 808     int r = 0;
 809
 810     switch (ipa1) {
 811     case PRIV_EB_SQBS:
 812         /* just inject exception */
 813         r = -1;
 814         break;
 815     default:
 816         r = -1;
 817         DPRINTF("KVM: unhandled PRIV: 0xeb%x\n", ipa1);
 818         break;
 819     }
 820
 821     return r;
 822 }
 823
 824 static int handle_hypercall(S390CPU *cpu, struct kvm_run *run)
 825 {
 826     CPUS390XState *env = &cpu->env;
 827     int ret;
 828
 829     cpu_synchronize_state(CPU(cpu));
 830     ret = s390_virtio_hypercall(env);
 831     if (ret == -EINVAL) {
 832         enter_pgmcheck(cpu, PGM_SPECIFICATION);
 833         return 0;
 834     }
 835
 836     return ret;
 837 }
 838
 839 static void kvm_handle_diag_308(S390CPU *cpu, struct kvm_run *run)
 840 {
 841     uint64_t r1, r3;
 842
 843     cpu_synchronize_state(CPU(cpu));
 844     r1 = (run->s390_sieic.ipa & 0x00f0) >> 8;
 845     r3 = run->s390_sieic.ipa & 0x000f;
 846     handle_diag_308(&cpu->env, r1, r3);
 847 }
 848
 849 static int handle_sw_breakpoint(S390CPU *cpu, struct kvm_run *run)
 850 {
 851     CPUS390XState *env = &cpu->env;
 852     unsigned long pc;
 853
 854     cpu_synchronize_state(CPU(cpu));
 855
 856     pc = env->psw.addr - 4;
 857     if (kvm_find_sw_breakpoint(CPU(cpu), pc)) {
 858         env->psw.addr = pc;
 859         return EXCP_DEBUG;
 860     }
 861
 862     return -ENOENT;
 863 }
 864
 865 #define DIAG_KVM_CODE_MASK 0x000000000000ffff
 866
 867 static int handle_diag(S390CPU *cpu, struct kvm_run *run, uint32_t ipb)
 868 {
 869     int r = 0;
 870     uint16_t func_code;
 871
 872     /*
 873      * For any diagnose call we support, bits 48-63 of the resulting
 874      * address specify the function code; the remainder is ignored.
 875      */
 876     func_code = decode_basedisp_rs(&cpu->env, ipb) & DIAG_KVM_CODE_MASK;
 877     switch (func_code) {
 878     case DIAG_IPL:
 879         kvm_handle_diag_308(cpu, run);
 880         break;
 881     case DIAG_KVM_HYPERCALL:
 882         r = handle_hypercall(cpu, run);
 883         break;
 884     case DIAG_KVM_BREAKPOINT:
 885         r = handle_sw_breakpoint(cpu, run);
 886         break;
 887     default:
 888         DPRINTF("KVM: unknown DIAG: 0x%x\n", func_code);
 889         r = -1;
 890         break;
 891     }
 892
 893     return r;
 894 }
 895
 896 static int kvm_s390_cpu_start(S390CPU *cpu)
 897 {
 898     s390_add_running_cpu(cpu);
 899     qemu_cpu_kick(CPU(cpu));
 900     DPRINTF("DONE: KVM cpu start: %p\n", &cpu->env);
 901     return 0;
 902 }
 903
 904 int kvm_s390_cpu_restart(S390CPU *cpu)
 905 {
 906     struct kvm_s390_irq irq = {
 907         .type = KVM_S390_RESTART,
 908     };
 909
 910     kvm_s390_vcpu_interrupt(cpu, &irq);
 911     s390_add_running_cpu(cpu);
 912     qemu_cpu_kick(CPU(cpu));
 913     DPRINTF("DONE: KVM cpu restart: %p\n", &cpu->env);
 914     return 0;
 915 }
 916
 917 static void sigp_initial_cpu_reset(void *arg)
 918 {
 919     CPUState *cpu = arg;
 920     S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
 921
 922     cpu_synchronize_state(cpu);
 923     scc->initial_cpu_reset(cpu);
 924 }
 925
 926 static void sigp_cpu_reset(void *arg)
 927 {
 928     CPUState *cpu = arg;
 929     S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
 930
 931     cpu_synchronize_state(cpu);
 932     scc->cpu_reset(cpu);
 933 }
 934
 935 #define SIGP_ORDER_MASK 0x000000ff
 936
 937 static int handle_sigp(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
 938 {
 939     CPUS390XState *env = &cpu->env;
 940     uint8_t order_code;
 941     uint16_t cpu_addr;
 942     S390CPU *target_cpu;
 943     uint64_t *statusreg = &env->regs[ipa1 >> 4];
 944     int cc;
 945
 946     cpu_synchronize_state(CPU(cpu));
 947
 948     /* get order code */
 949     order_code = decode_basedisp_rs(env, run->s390_sieic.ipb) & SIGP_ORDER_MASK;
 950
 951     cpu_addr = env->regs[ipa1 & 0x0f];
 952     target_cpu = s390_cpu_addr2state(cpu_addr);
 953     if (target_cpu == NULL) {
 954         cc = 3;    /* not operational */
 955         goto out;
 956     }
 957
 958     switch (order_code) {
 959     case SIGP_START:
 960         cc = kvm_s390_cpu_start(target_cpu);
 961         break;
 962     case SIGP_RESTART:
 963         cc = kvm_s390_cpu_restart(target_cpu);
 964         break;
 965     case SIGP_SET_ARCH:
 966         *statusreg &= 0xffffffff00000000UL;
 967         *statusreg |= SIGP_STAT_INVALID_PARAMETER;
 968         cc = 1;   /* status stored */
 969         break;
 970     case SIGP_INITIAL_CPU_RESET:
 971         run_on_cpu(CPU(target_cpu), sigp_initial_cpu_reset, CPU(target_cpu));
 972         cc = 0;
 973         break;
 974     case SIGP_CPU_RESET:
 975         run_on_cpu(CPU(target_cpu), sigp_cpu_reset, CPU(target_cpu));
 976         cc = 0;
 977         break;
 978     default:
 979         DPRINTF("KVM: unknown SIGP: 0x%x\n", order_code);
 980         *statusreg &= 0xffffffff00000000UL;
 981         *statusreg |= SIGP_STAT_INVALID_ORDER;
 982         cc = 1;   /* status stored */
 983         break;
 984     }
 985
 986 out:
 987     setcc(cpu, cc);
 988     return 0;
 989 }
 990
 991 static int handle_instruction(S390CPU *cpu, struct kvm_run *run)
 992 {
 993     unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
 994     uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
 995     int r = -1;
 996
 997     DPRINTF("handle_instruction 0x%x 0x%x\n",
 998             run->s390_sieic.ipa, run->s390_sieic.ipb);
 999     switch (ipa0) {
1000     case IPA0_B2:
1001         r = handle_b2(cpu, run, ipa1);
1002         break;
1003     case IPA0_B9:
1004         r = handle_b9(cpu, run, ipa1);
1005         break;
1006     case IPA0_EB:
1007         r = handle_eb(cpu, run, ipa1);
1008         break;
1009     case IPA0_DIAG:
1010         r = handle_diag(cpu, run, run->s390_sieic.ipb);
1011         break;
1012     case IPA0_SIGP:
1013         r = handle_sigp(cpu, run, ipa1);
1014         break;
1015     }
1016
1017     if (r < 0) {
1018         r = 0;
1019         enter_pgmcheck(cpu, 0x0001);
1020     }
1021
1022     return r;
1023 }
1024
1025 static bool is_special_wait_psw(CPUState *cs)
1026 {
1027     /* signal quiesce */
1028     return cs->kvm_run->psw_addr == 0xfffUL;
1029 }
1030
1031 static void guest_panicked(void)
1032 {
1033     qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE,
1034                                    &error_abort);
1035     vm_stop(RUN_STATE_GUEST_PANICKED);
1036 }
1037
1038 static void unmanageable_intercept(S390CPU *cpu, const char *str, int pswoffset)
1039 {
1040     CPUState *cs = CPU(cpu);
1041
1042     error_report("Unmanageable %s! CPU%i new PSW: 0x%016lx:%016lx",
1043                  str, cs->cpu_index, ldq_phys(cs->as, cpu->env.psa + pswoffset),
1044                  ldq_phys(cs->as, cpu->env.psa + pswoffset + 8));
1045     s390_del_running_cpu(cpu);
1046     guest_panicked();
1047 }
1048
1049 static int handle_intercept(S390CPU *cpu)
1050 {
1051     CPUState *cs = CPU(cpu);
1052     struct kvm_run *run = cs->kvm_run;
1053     int icpt_code = run->s390_sieic.icptcode;
1054     int r = 0;
1055
1056     DPRINTF("intercept: 0x%x (at 0x%lx)\n", icpt_code,
1057             (long)cs->kvm_run->psw_addr);
1058     switch (icpt_code) {
1059         case ICPT_INSTRUCTION:
1060             r = handle_instruction(cpu, run);
1061             break;
1062         case ICPT_PROGRAM:
1063             unmanageable_intercept(cpu, "program interrupt",
1064                                    offsetof(LowCore, program_new_psw));
1065             r = EXCP_HALTED;
1066             break;
1067         case ICPT_EXT_INT:
1068             unmanageable_intercept(cpu, "external interrupt",
1069                                    offsetof(LowCore, external_new_psw));
1070             r = EXCP_HALTED;
1071             break;
1072         case ICPT_WAITPSW:
1073             /* disabled wait, since enabled wait is handled in kernel */
1074             if (s390_del_running_cpu(cpu) == 0) {
1075                 if (is_special_wait_psw(cs)) {
1076                     qemu_system_shutdown_request();
1077                 } else {
1078                     guest_panicked();
1079                 }
1080             }
1081             r = EXCP_HALTED;
1082             break;
1083         case ICPT_CPU_STOP:
1084             if (s390_del_running_cpu(cpu) == 0) {
1085                 qemu_system_shutdown_request();
1086             }
1087             r = EXCP_HALTED;
1088             break;
1089         case ICPT_SOFT_INTERCEPT:
1090             fprintf(stderr, "KVM unimplemented icpt SOFT\n");
1091             exit(1);
1092             break;
1093         case ICPT_IO:
1094             fprintf(stderr, "KVM unimplemented icpt IO\n");
1095             exit(1);
1096             break;
1097         default:
1098             fprintf(stderr, "Unknown intercept code: %d\n", icpt_code);
1099             exit(1);
1100             break;
1101     }
1102
1103     return r;
1104 }
1105
1106 static int handle_tsch(S390CPU *cpu)
1107 {
1108     CPUS390XState *env = &cpu->env;
1109     CPUState *cs = CPU(cpu);
1110     struct kvm_run *run = cs->kvm_run;
1111     int ret;
1112
1113     cpu_synchronize_state(cs);
1114
1115     ret = ioinst_handle_tsch(env, env->regs[1], run->s390_tsch.ipb);
1116     if (ret >= 0) {
1117         /* Success; set condition code. */
1118         setcc(cpu, ret);
1119         ret = 0;
1120     } else if (ret < -1) {
1121         /*
1122          * Failure.
1123          * If an I/O interrupt had been dequeued, we have to reinject it.
1124          */
1125         if (run->s390_tsch.dequeued) {
1126             kvm_s390_io_interrupt(run->s390_tsch.subchannel_id,
1127                                   run->s390_tsch.subchannel_nr,
1128                                   run->s390_tsch.io_int_parm,
1129                                   run->s390_tsch.io_int_word);
1130         }
1131         ret = 0;
1132     }
1133     return ret;
1134 }
1135
1136 static int kvm_arch_handle_debug_exit(S390CPU *cpu)
1137 {
1138     CPUState *cs = CPU(cpu);
1139     struct kvm_run *run = cs->kvm_run;
1140
1141     int ret = 0;
1142     struct kvm_debug_exit_arch *arch_info = &run->debug.arch;
1143
1144     switch (arch_info->type) {
1145     case KVM_HW_WP_WRITE:
1146         if (find_hw_breakpoint(arch_info->addr, -1, arch_info->type)) {
1147             cs->watchpoint_hit = &hw_watchpoint;
1148             hw_watchpoint.vaddr = arch_info->addr;
1149             hw_watchpoint.flags = BP_MEM_WRITE;
1150             ret = EXCP_DEBUG;
1151         }
1152         break;
1153     case KVM_HW_BP:
1154         if (find_hw_breakpoint(arch_info->addr, -1, arch_info->type)) {
1155             ret = EXCP_DEBUG;
1156         }
1157         break;
1158     case KVM_SINGLESTEP:
1159         if (cs->singlestep_enabled) {
1160             ret = EXCP_DEBUG;
1161         }
1162         break;
1163     default:
1164         ret = -ENOSYS;
1165     }
1166
1167     return ret;
1168 }
1169
1170 int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
1171 {
1172     S390CPU *cpu = S390_CPU(cs);
1173     int ret = 0;
1174
1175     switch (run->exit_reason) {
1176         case KVM_EXIT_S390_SIEIC:
1177             ret = handle_intercept(cpu);
1178             break;
1179         case KVM_EXIT_S390_RESET:
1180             qemu_system_reset_request();
1181             break;
1182         case KVM_EXIT_S390_TSCH:
1183             ret = handle_tsch(cpu);
1184             break;
1185         case KVM_EXIT_DEBUG:
1186             ret = kvm_arch_handle_debug_exit(cpu);
1187             break;
1188         default:
1189             fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
1190             break;
1191     }
1192
1193     if (ret == 0) {
1194         ret = EXCP_INTERRUPT;
1195     }
1196     return ret;
1197 }
1198
1199 bool kvm_arch_stop_on_emulation_error(CPUState *cpu)
1200 {
1201     return true;
1202 }
1203
1204 int kvm_arch_on_sigbus_vcpu(CPUState *cpu, int code, void *addr)
1205 {
1206     return 1;
1207 }
1208
1209 int kvm_arch_on_sigbus(int code, void *addr)
1210 {
1211     return 1;
1212 }
1213
1214 void kvm_s390_io_interrupt(uint16_t subchannel_id,
1215                            uint16_t subchannel_nr, uint32_t io_int_parm,
1216                            uint32_t io_int_word)
1217 {
1218     struct kvm_s390_irq irq = {
1219         .u.io.subchannel_id = subchannel_id,
1220         .u.io.subchannel_nr = subchannel_nr,
1221         .u.io.io_int_parm = io_int_parm,
1222         .u.io.io_int_word = io_int_word,
1223     };
1224
1225     if (io_int_word & IO_INT_WORD_AI) {
1226         irq.type = KVM_S390_INT_IO(1, 0, 0, 0);
1227     } else {
1228         irq.type = ((subchannel_id & 0xff00) << 24) |
1229             ((subchannel_id & 0x00060) << 22) | (subchannel_nr << 16);
1230     }
1231     kvm_s390_floating_interrupt(&irq);
1232 }
1233
1234 void kvm_s390_crw_mchk(void)
1235 {
1236     struct kvm_s390_irq irq = {
1237         .type = KVM_S390_MCHK,
1238         .u.mchk.cr14 = 1 << 28,
1239         .u.mchk.mcic = 0x00400f1d40330000,
1240     };
1241     kvm_s390_floating_interrupt(&irq);
1242 }
1243
1244 void kvm_s390_enable_css_support(S390CPU *cpu)
1245 {
1246     int r;
1247
1248     /* Activate host kernel channel subsystem support. */
1249     r = kvm_vcpu_enable_cap(CPU(cpu), KVM_CAP_S390_CSS_SUPPORT, 0);
1250     assert(r == 0);
1251 }
1252
1253 void kvm_arch_init_irq_routing(KVMState *s)
1254 {
1255     /*
1256      * Note that while irqchip capabilities generally imply that cpustates
1257      * are handled in-kernel, it is not true for s390 (yet); therefore, we
1258      * have to override the common code kvm_halt_in_kernel_allowed setting.
1259      */
1260     if (kvm_check_extension(s, KVM_CAP_IRQ_ROUTING)) {
1261         kvm_irqfds_allowed = true;
1262         kvm_gsi_routing_allowed = true;
1263         kvm_halt_in_kernel_allowed = false;
1264     }
1265 }
1266
1267 int kvm_s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch,
1268                                     int vq, bool assign)
1269 {
1270     struct kvm_ioeventfd kick = {
1271         .flags = KVM_IOEVENTFD_FLAG_VIRTIO_CCW_NOTIFY |
1272         KVM_IOEVENTFD_FLAG_DATAMATCH,
1273         .fd = event_notifier_get_fd(notifier),
1274         .datamatch = vq,
1275         .addr = sch,
1276         .len = 8,
1277     };
1278     if (!kvm_check_extension(kvm_state, KVM_CAP_IOEVENTFD)) {
1279         return -ENOSYS;
1280     }
1281     if (!assign) {
1282         kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
1283     }
1284     return kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
1285 }