arch/s390/kvm/kvm-s390.c

   1 /*
   2  * hosting zSeries kernel virtual machines
   3  *
   4  * Copyright IBM Corp. 2008, 2009
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License (version 2 only)
   8  * as published by the Free Software Foundation.
   9  *
  10  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  11  *               Christian Borntraeger <borntraeger@de.ibm.com>
  12  *               Heiko Carstens <heiko.carstens@de.ibm.com>
  13  *               Christian Ehrhardt <ehrhardt@de.ibm.com>
  14  */
  15
  16 #include <linux/compiler.h>
  17 #include <linux/err.h>
  18 #include <linux/fs.h>
  19 #include <linux/hrtimer.h>
  20 #include <linux/init.h>
  21 #include <linux/kvm.h>
  22 #include <linux/kvm_host.h>
  23 #include <linux/module.h>
  24 #include <linux/slab.h>
  25 #include <linux/timer.h>
  26 #include <asm/asm-offsets.h>
  27 #include <asm/lowcore.h>
  28 #include <asm/pgtable.h>
  29 #include <asm/nmi.h>
  30 #include <asm/switch_to.h>
  31 #include <asm/sclp.h>
  32 #include "kvm-s390.h"
  33 #include "gaccess.h"
  34
  35 #define CREATE_TRACE_POINTS
  36 #include "trace.h"
  37 #include "trace-s390.h"
  38
  39 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
  40
  41 struct kvm_stats_debugfs_item debugfs_entries[] = {
  42         { "userspace_handled", VCPU_STAT(exit_userspace) },
  43         { "exit_null", VCPU_STAT(exit_null) },
  44         { "exit_validity", VCPU_STAT(exit_validity) },
  45         { "exit_stop_request", VCPU_STAT(exit_stop_request) },
  46         { "exit_external_request", VCPU_STAT(exit_external_request) },
  47         { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
  48         { "exit_instruction", VCPU_STAT(exit_instruction) },
  49         { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
  50         { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
  51         { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
  52         { "instruction_lctl", VCPU_STAT(instruction_lctl) },
  53         { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
  54         { "deliver_external_call", VCPU_STAT(deliver_external_call) },
  55         { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
  56         { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
  57         { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
  58         { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
  59         { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
  60         { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
  61         { "exit_wait_state", VCPU_STAT(exit_wait_state) },
  62         { "instruction_stidp", VCPU_STAT(instruction_stidp) },
  63         { "instruction_spx", VCPU_STAT(instruction_spx) },
  64         { "instruction_stpx", VCPU_STAT(instruction_stpx) },
  65         { "instruction_stap", VCPU_STAT(instruction_stap) },
  66         { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
  67         { "instruction_stsch", VCPU_STAT(instruction_stsch) },
  68         { "instruction_chsc", VCPU_STAT(instruction_chsc) },
  69         { "instruction_stsi", VCPU_STAT(instruction_stsi) },
  70         { "instruction_stfl", VCPU_STAT(instruction_stfl) },
  71         { "instruction_tprot", VCPU_STAT(instruction_tprot) },
  72         { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
  73         { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
  74         { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
  75         { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
  76         { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
  77         { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
  78         { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
  79         { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
  80         { "diagnose_10", VCPU_STAT(diagnose_10) },
  81         { "diagnose_44", VCPU_STAT(diagnose_44) },
  82         { "diagnose_9c", VCPU_STAT(diagnose_9c) },
  83         { NULL }
  84 };
  85
  86 static unsigned long long *facilities;
  87
  88 /* Section: not file related */
  89 int kvm_arch_hardware_enable(void *garbage)
  90 {
  91         /* every s390 is virtualization enabled ;-) */
  92         return 0;
  93 }
  94
  95 void kvm_arch_hardware_disable(void *garbage)
  96 {
  97 }
  98
  99 int kvm_arch_hardware_setup(void)
 100 {
 101         return 0;
 102 }
 103
 104 void kvm_arch_hardware_unsetup(void)
 105 {
 106 }
 107
 108 void kvm_arch_check_processor_compat(void *rtn)
 109 {
 110 }
 111
 112 int kvm_arch_init(void *opaque)
 113 {
 114         return 0;
 115 }
 116
 117 void kvm_arch_exit(void)
 118 {
 119 }
 120
 121 /* Section: device related */
 122 long kvm_arch_dev_ioctl(struct file *filp,
 123                         unsigned int ioctl, unsigned long arg)
 124 {
 125         if (ioctl == KVM_S390_ENABLE_SIE)
 126                 return s390_enable_sie();
 127         return -EINVAL;
 128 }
 129
 130 int kvm_dev_ioctl_check_extension(long ext)
 131 {
 132         int r;
 133
 134         switch (ext) {
 135         case KVM_CAP_S390_PSW:
 136         case KVM_CAP_S390_GMAP:
 137         case KVM_CAP_SYNC_MMU:
 138 #ifdef CONFIG_KVM_S390_UCONTROL
 139         case KVM_CAP_S390_UCONTROL:
 140 #endif
 141         case KVM_CAP_SYNC_REGS:
 142         case KVM_CAP_ONE_REG:
 143         case KVM_CAP_ENABLE_CAP:
 144         case KVM_CAP_S390_CSS_SUPPORT:
 145         case KVM_CAP_IOEVENTFD:
 146                 r = 1;
 147                 break;
 148         case KVM_CAP_NR_VCPUS:
 149         case KVM_CAP_MAX_VCPUS:
 150                 r = KVM_MAX_VCPUS;
 151                 break;
 152         case KVM_CAP_S390_COW:
 153                 r = MACHINE_HAS_ESOP;
 154                 break;
 155         default:
 156                 r = 0;
 157         }
 158         return r;
 159 }
 160
 161 /* Section: vm related */
 162 /*
 163  * Get (and clear) the dirty memory log for a memory slot.
 164  */
 165 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
 166                                struct kvm_dirty_log *log)
 167 {
 168         return 0;
 169 }
 170
 171 long kvm_arch_vm_ioctl(struct file *filp,
 172                        unsigned int ioctl, unsigned long arg)
 173 {
 174         struct kvm *kvm = filp->private_data;
 175         void __user *argp = (void __user *)arg;
 176         int r;
 177
 178         switch (ioctl) {
 179         case KVM_S390_INTERRUPT: {
 180                 struct kvm_s390_interrupt s390int;
 181
 182                 r = -EFAULT;
 183                 if (copy_from_user(&s390int, argp, sizeof(s390int)))
 184                         break;
 185                 r = kvm_s390_inject_vm(kvm, &s390int);
 186                 break;
 187         }
 188         default:
 189                 r = -ENOTTY;
 190         }
 191
 192         return r;
 193 }
 194
 195 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
 196 {
 197         int rc;
 198         char debug_name[16];
 199
 200         rc = -EINVAL;
 201 #ifdef CONFIG_KVM_S390_UCONTROL
 202         if (type & ~KVM_VM_S390_UCONTROL)
 203                 goto out_err;
 204         if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
 205                 goto out_err;
 206 #else
 207         if (type)
 208                 goto out_err;
 209 #endif
 210
 211         rc = s390_enable_sie();
 212         if (rc)
 213                 goto out_err;
 214
 215         rc = -ENOMEM;
 216
 217         kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
 218         if (!kvm->arch.sca)
 219                 goto out_err;
 220
 221         sprintf(debug_name, "kvm-%u", current->pid);
 222
 223         kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
 224         if (!kvm->arch.dbf)
 225                 goto out_nodbf;
 226
 227         spin_lock_init(&kvm->arch.float_int.lock);
 228         INIT_LIST_HEAD(&kvm->arch.float_int.list);
 229
 230         debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
 231         VM_EVENT(kvm, 3, "%s", "vm created");
 232
 233         if (type & KVM_VM_S390_UCONTROL) {
 234                 kvm->arch.gmap = NULL;
 235         } else {
 236                 kvm->arch.gmap = gmap_alloc(current->mm);
 237                 if (!kvm->arch.gmap)
 238                         goto out_nogmap;
 239         }
 240
 241         kvm->arch.css_support = 0;
 242
 243         return 0;
 244 out_nogmap:
 245         debug_unregister(kvm->arch.dbf);
 246 out_nodbf:
 247         free_page((unsigned long)(kvm->arch.sca));
 248 out_err:
 249         return rc;
 250 }
 251
 252 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
 253 {
 254         VCPU_EVENT(vcpu, 3, "%s", "free cpu");
 255         trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
 256         if (!kvm_is_ucontrol(vcpu->kvm)) {
 257                 clear_bit(63 - vcpu->vcpu_id,
 258                           (unsigned long *) &vcpu->kvm->arch.sca->mcn);
 259                 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
 260                     (__u64) vcpu->arch.sie_block)
 261                         vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
 262         }
 263         smp_mb();
 264
 265         if (kvm_is_ucontrol(vcpu->kvm))
 266                 gmap_free(vcpu->arch.gmap);
 267
 268         free_page((unsigned long)(vcpu->arch.sie_block));
 269         kvm_vcpu_uninit(vcpu);
 270         kfree(vcpu);
 271 }
 272
 273 static void kvm_free_vcpus(struct kvm *kvm)
 274 {
 275         unsigned int i;
 276         struct kvm_vcpu *vcpu;
 277
 278         kvm_for_each_vcpu(i, vcpu, kvm)
 279                 kvm_arch_vcpu_destroy(vcpu);
 280
 281         mutex_lock(&kvm->lock);
 282         for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
 283                 kvm->vcpus[i] = NULL;
 284
 285         atomic_set(&kvm->online_vcpus, 0);
 286         mutex_unlock(&kvm->lock);
 287 }
 288
 289 void kvm_arch_sync_events(struct kvm *kvm)
 290 {
 291 }
 292
 293 void kvm_arch_destroy_vm(struct kvm *kvm)
 294 {
 295         kvm_free_vcpus(kvm);
 296         free_page((unsigned long)(kvm->arch.sca));
 297         debug_unregister(kvm->arch.dbf);
 298         if (!kvm_is_ucontrol(kvm))
 299                 gmap_free(kvm->arch.gmap);
 300 }
 301
 302 /* Section: vcpu related */
 303 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
 304 {
 305         if (kvm_is_ucontrol(vcpu->kvm)) {
 306                 vcpu->arch.gmap = gmap_alloc(current->mm);
 307                 if (!vcpu->arch.gmap)
 308                         return -ENOMEM;
 309                 return 0;
 310         }
 311
 312         vcpu->arch.gmap = vcpu->kvm->arch.gmap;
 313         vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
 314                                     KVM_SYNC_GPRS |
 315                                     KVM_SYNC_ACRS |
 316                                     KVM_SYNC_CRS;
 317         return 0;
 318 }
 319
 320 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
 321 {
 322         /* Nothing todo */
 323 }
 324
 325 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
 326 {
 327         save_fp_regs(&vcpu->arch.host_fpregs);
 328         save_access_regs(vcpu->arch.host_acrs);
 329         vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
 330         restore_fp_regs(&vcpu->arch.guest_fpregs);
 331         restore_access_regs(vcpu->run->s.regs.acrs);
 332         gmap_enable(vcpu->arch.gmap);
 333         atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
 334 }
 335
 336 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
 337 {
 338         atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
 339         gmap_disable(vcpu->arch.gmap);
 340         save_fp_regs(&vcpu->arch.guest_fpregs);
 341         save_access_regs(vcpu->run->s.regs.acrs);
 342         restore_fp_regs(&vcpu->arch.host_fpregs);
 343         restore_access_regs(vcpu->arch.host_acrs);
 344 }
 345
 346 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
 347 {
 348         /* this equals initial cpu reset in pop, but we don't switch to ESA */
 349         vcpu->arch.sie_block->gpsw.mask = 0UL;
 350         vcpu->arch.sie_block->gpsw.addr = 0UL;
 351         kvm_s390_set_prefix(vcpu, 0);
 352         vcpu->arch.sie_block->cputm     = 0UL;
 353         vcpu->arch.sie_block->ckc       = 0UL;
 354         vcpu->arch.sie_block->todpr     = 0;
 355         memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
 356         vcpu->arch.sie_block->gcr[0]  = 0xE0UL;
 357         vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
 358         vcpu->arch.guest_fpregs.fpc = 0;
 359         asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
 360         vcpu->arch.sie_block->gbea = 1;
 361         atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
 362 }
 363
 364 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
 365 {
 366         return 0;
 367 }
 368
 369 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
 370 {
 371         atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
 372                                                     CPUSTAT_SM |
 373                                                     CPUSTAT_STOPPED);
 374         vcpu->arch.sie_block->ecb   = 6;
 375         vcpu->arch.sie_block->eca   = 0xC1002001U;
 376         vcpu->arch.sie_block->fac   = (int) (long) facilities;
 377         hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
 378         tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
 379                      (unsigned long) vcpu);
 380         vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
 381         get_cpu_id(&vcpu->arch.cpu_id);
 382         vcpu->arch.cpu_id.version = 0xff;
 383         return 0;
 384 }
 385
 386 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
 387                                       unsigned int id)
 388 {
 389         struct kvm_vcpu *vcpu;
 390         int rc = -EINVAL;
 391
 392         if (id >= KVM_MAX_VCPUS)
 393                 goto out;
 394
 395         rc = -ENOMEM;
 396
 397         vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
 398         if (!vcpu)
 399                 goto out;
 400
 401         vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
 402                                         get_zeroed_page(GFP_KERNEL);
 403
 404         if (!vcpu->arch.sie_block)
 405                 goto out_free_cpu;
 406
 407         vcpu->arch.sie_block->icpua = id;
 408         if (!kvm_is_ucontrol(kvm)) {
 409                 if (!kvm->arch.sca) {
 410                         WARN_ON_ONCE(1);
 411                         goto out_free_cpu;
 412                 }
 413                 if (!kvm->arch.sca->cpu[id].sda)
 414                         kvm->arch.sca->cpu[id].sda =
 415                                 (__u64) vcpu->arch.sie_block;
 416                 vcpu->arch.sie_block->scaoh =
 417                         (__u32)(((__u64)kvm->arch.sca) >> 32);
 418                 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
 419                 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
 420         }
 421
 422         spin_lock_init(&vcpu->arch.local_int.lock);
 423         INIT_LIST_HEAD(&vcpu->arch.local_int.list);
 424         vcpu->arch.local_int.float_int = &kvm->arch.float_int;
 425         spin_lock(&kvm->arch.float_int.lock);
 426         kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
 427         init_waitqueue_head(&vcpu->arch.local_int.wq);
 428         vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
 429         spin_unlock(&kvm->arch.float_int.lock);
 430
 431         rc = kvm_vcpu_init(vcpu, kvm, id);
 432         if (rc)
 433                 goto out_free_sie_block;
 434         VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
 435                  vcpu->arch.sie_block);
 436         trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
 437
 438         return vcpu;
 439 out_free_sie_block:
 440         free_page((unsigned long)(vcpu->arch.sie_block));
 441 out_free_cpu:
 442         kfree(vcpu);
 443 out:
 444         return ERR_PTR(rc);
 445 }
 446
 447 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
 448 {
 449         /* kvm common code refers to this, but never calls it */
 450         BUG();
 451         return 0;
 452 }
 453
 454 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
 455 {
 456         /* kvm common code refers to this, but never calls it */
 457         BUG();
 458         return 0;
 459 }
 460
 461 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
 462                                            struct kvm_one_reg *reg)
 463 {
 464         int r = -EINVAL;
 465
 466         switch (reg->id) {
 467         case KVM_REG_S390_TODPR:
 468                 r = put_user(vcpu->arch.sie_block->todpr,
 469                              (u32 __user *)reg->addr);
 470                 break;
 471         case KVM_REG_S390_EPOCHDIFF:
 472                 r = put_user(vcpu->arch.sie_block->epoch,
 473                              (u64 __user *)reg->addr);
 474                 break;
 475         case KVM_REG_S390_CPU_TIMER:
 476                 r = put_user(vcpu->arch.sie_block->cputm,
 477                              (u64 __user *)reg->addr);
 478                 break;
 479         case KVM_REG_S390_CLOCK_COMP:
 480                 r = put_user(vcpu->arch.sie_block->ckc,
 481                              (u64 __user *)reg->addr);
 482                 break;
 483         default:
 484                 break;
 485         }
 486
 487         return r;
 488 }
 489
 490 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
 491                                            struct kvm_one_reg *reg)
 492 {
 493         int r = -EINVAL;
 494
 495         switch (reg->id) {
 496         case KVM_REG_S390_TODPR:
 497                 r = get_user(vcpu->arch.sie_block->todpr,
 498                              (u32 __user *)reg->addr);
 499                 break;
 500         case KVM_REG_S390_EPOCHDIFF:
 501                 r = get_user(vcpu->arch.sie_block->epoch,
 502                              (u64 __user *)reg->addr);
 503                 break;
 504         case KVM_REG_S390_CPU_TIMER:
 505                 r = get_user(vcpu->arch.sie_block->cputm,
 506                              (u64 __user *)reg->addr);
 507                 break;
 508         case KVM_REG_S390_CLOCK_COMP:
 509                 r = get_user(vcpu->arch.sie_block->ckc,
 510                              (u64 __user *)reg->addr);
 511                 break;
 512         default:
 513                 break;
 514         }
 515
 516         return r;
 517 }
 518
 519 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
 520 {
 521         kvm_s390_vcpu_initial_reset(vcpu);
 522         return 0;
 523 }
 524
 525 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
 526 {
 527         memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
 528         return 0;
 529 }
 530
 531 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
 532 {
 533         memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
 534         return 0;
 535 }
 536
 537 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
 538                                   struct kvm_sregs *sregs)
 539 {
 540         memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
 541         memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
 542         restore_access_regs(vcpu->run->s.regs.acrs);
 543         return 0;
 544 }
 545
 546 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
 547                                   struct kvm_sregs *sregs)
 548 {
 549         memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
 550         memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
 551         return 0;
 552 }
 553
 554 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 555 {
 556         memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
 557         vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK;
 558         restore_fp_regs(&vcpu->arch.guest_fpregs);
 559         return 0;
 560 }
 561
 562 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 563 {
 564         memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
 565         fpu->fpc = vcpu->arch.guest_fpregs.fpc;
 566         return 0;
 567 }
 568
 569 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
 570 {
 571         int rc = 0;
 572
 573         if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
 574                 rc = -EBUSY;
 575         else {
 576                 vcpu->run->psw_mask = psw.mask;
 577                 vcpu->run->psw_addr = psw.addr;
 578         }
 579         return rc;
 580 }
 581
 582 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
 583                                   struct kvm_translation *tr)
 584 {
 585         return -EINVAL; /* not implemented yet */
 586 }
 587
 588 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
 589                                         struct kvm_guest_debug *dbg)
 590 {
 591         return -EINVAL; /* not implemented yet */
 592 }
 593
 594 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
 595                                     struct kvm_mp_state *mp_state)
 596 {
 597         return -EINVAL; /* not implemented yet */
 598 }
 599
 600 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
 601                                     struct kvm_mp_state *mp_state)
 602 {
 603         return -EINVAL; /* not implemented yet */
 604 }
 605
 606 static int __vcpu_run(struct kvm_vcpu *vcpu)
 607 {
 608         int rc;
 609
 610         memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
 611
 612         if (need_resched())
 613                 schedule();
 614
 615         if (test_thread_flag(TIF_MCCK_PENDING))
 616                 s390_handle_mcck();
 617
 618         if (!kvm_is_ucontrol(vcpu->kvm))
 619                 kvm_s390_deliver_pending_interrupts(vcpu);
 620
 621         vcpu->arch.sie_block->icptcode = 0;
 622         preempt_disable();
 623         kvm_guest_enter();
 624         preempt_enable();
 625         VCPU_EVENT(vcpu, 6, "entering sie flags %x",
 626                    atomic_read(&vcpu->arch.sie_block->cpuflags));
 627         trace_kvm_s390_sie_enter(vcpu,
 628                                  atomic_read(&vcpu->arch.sie_block->cpuflags));
 629         rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
 630         if (rc) {
 631                 if (kvm_is_ucontrol(vcpu->kvm)) {
 632                         rc = SIE_INTERCEPT_UCONTROL;
 633                 } else {
 634                         VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
 635                         trace_kvm_s390_sie_fault(vcpu);
 636                         rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
 637                 }
 638         }
 639         VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
 640                    vcpu->arch.sie_block->icptcode);
 641         trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
 642         kvm_guest_exit();
 643
 644         memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
 645         return rc;
 646 }
 647
 648 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 649 {
 650         int rc;
 651         sigset_t sigsaved;
 652
 653 rerun_vcpu:
 654         if (vcpu->sigset_active)
 655                 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
 656
 657         atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
 658
 659         BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
 660
 661         switch (kvm_run->exit_reason) {
 662         case KVM_EXIT_S390_SIEIC:
 663         case KVM_EXIT_UNKNOWN:
 664         case KVM_EXIT_INTR:
 665         case KVM_EXIT_S390_RESET:
 666         case KVM_EXIT_S390_UCONTROL:
 667         case KVM_EXIT_S390_TSCH:
 668                 break;
 669         default:
 670                 BUG();
 671         }
 672
 673         vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
 674         vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
 675         if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
 676                 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
 677                 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
 678         }
 679         if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
 680                 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
 681                 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
 682                 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
 683         }
 684
 685         might_fault();
 686
 687         do {
 688                 rc = __vcpu_run(vcpu);
 689                 if (rc)
 690                         break;
 691                 if (kvm_is_ucontrol(vcpu->kvm))
 692                         rc = -EOPNOTSUPP;
 693                 else
 694                         rc = kvm_handle_sie_intercept(vcpu);
 695         } while (!signal_pending(current) && !rc);
 696
 697         if (rc == SIE_INTERCEPT_RERUNVCPU)
 698                 goto rerun_vcpu;
 699
 700         if (signal_pending(current) && !rc) {
 701                 kvm_run->exit_reason = KVM_EXIT_INTR;
 702                 rc = -EINTR;
 703         }
 704
 705 #ifdef CONFIG_KVM_S390_UCONTROL
 706         if (rc == SIE_INTERCEPT_UCONTROL) {
 707                 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
 708                 kvm_run->s390_ucontrol.trans_exc_code =
 709                         current->thread.gmap_addr;
 710                 kvm_run->s390_ucontrol.pgm_code = 0x10;
 711                 rc = 0;
 712         }
 713 #endif
 714
 715         if (rc == -EOPNOTSUPP) {
 716                 /* intercept cannot be handled in-kernel, prepare kvm-run */
 717                 kvm_run->exit_reason         = KVM_EXIT_S390_SIEIC;
 718                 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
 719                 kvm_run->s390_sieic.ipa      = vcpu->arch.sie_block->ipa;
 720                 kvm_run->s390_sieic.ipb      = vcpu->arch.sie_block->ipb;
 721                 rc = 0;
 722         }
 723
 724         if (rc == -EREMOTE) {
 725                 /* intercept was handled, but userspace support is needed
 726                  * kvm_run has been prepared by the handler */
 727                 rc = 0;
 728         }
 729
 730         kvm_run->psw_mask     = vcpu->arch.sie_block->gpsw.mask;
 731         kvm_run->psw_addr     = vcpu->arch.sie_block->gpsw.addr;
 732         kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
 733         memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
 734
 735         if (vcpu->sigset_active)
 736                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
 737
 738         vcpu->stat.exit_userspace++;
 739         return rc;
 740 }
 741
 742 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
 743                        unsigned long n, int prefix)
 744 {
 745         if (prefix)
 746                 return copy_to_guest(vcpu, guestdest, from, n);
 747         else
 748                 return copy_to_guest_absolute(vcpu, guestdest, from, n);
 749 }
 750
 751 /*
 752  * store status at address
 753  * we use have two special cases:
 754  * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
 755  * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
 756  */
 757 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
 758 {
 759         unsigned char archmode = 1;
 760         int prefix;
 761
 762         if (addr == KVM_S390_STORE_STATUS_NOADDR) {
 763                 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
 764                         return -EFAULT;
 765                 addr = SAVE_AREA_BASE;
 766                 prefix = 0;
 767         } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
 768                 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
 769                         return -EFAULT;
 770                 addr = SAVE_AREA_BASE;
 771                 prefix = 1;
 772         } else
 773                 prefix = 0;
 774
 775         /*
 776          * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
 777          * copying in vcpu load/put. Lets update our copies before we save
 778          * it into the save area
 779          */
 780         save_fp_regs(&vcpu->arch.guest_fpregs);
 781         save_access_regs(vcpu->run->s.regs.acrs);
 782
 783         if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
 784                         vcpu->arch.guest_fpregs.fprs, 128, prefix))
 785                 return -EFAULT;
 786
 787         if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
 788                         vcpu->run->s.regs.gprs, 128, prefix))
 789                 return -EFAULT;
 790
 791         if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
 792                         &vcpu->arch.sie_block->gpsw, 16, prefix))
 793                 return -EFAULT;
 794
 795         if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
 796                         &vcpu->arch.sie_block->prefix, 4, prefix))
 797                 return -EFAULT;
 798
 799         if (__guestcopy(vcpu,
 800                         addr + offsetof(struct save_area, fp_ctrl_reg),
 801                         &vcpu->arch.guest_fpregs.fpc, 4, prefix))
 802                 return -EFAULT;
 803
 804         if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
 805                         &vcpu->arch.sie_block->todpr, 4, prefix))
 806                 return -EFAULT;
 807
 808         if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
 809                         &vcpu->arch.sie_block->cputm, 8, prefix))
 810                 return -EFAULT;
 811
 812         if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
 813                         &vcpu->arch.sie_block->ckc, 8, prefix))
 814                 return -EFAULT;
 815
 816         if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
 817                         &vcpu->run->s.regs.acrs, 64, prefix))
 818                 return -EFAULT;
 819
 820         if (__guestcopy(vcpu,
 821                         addr + offsetof(struct save_area, ctrl_regs),
 822                         &vcpu->arch.sie_block->gcr, 128, prefix))
 823                 return -EFAULT;
 824         return 0;
 825 }
 826
 827 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
 828                                      struct kvm_enable_cap *cap)
 829 {
 830         int r;
 831
 832         if (cap->flags)
 833                 return -EINVAL;
 834
 835         switch (cap->cap) {
 836         case KVM_CAP_S390_CSS_SUPPORT:
 837                 if (!vcpu->kvm->arch.css_support) {
 838                         vcpu->kvm->arch.css_support = 1;
 839                         trace_kvm_s390_enable_css(vcpu->kvm);
 840                 }
 841                 r = 0;
 842                 break;
 843         default:
 844                 r = -EINVAL;
 845                 break;
 846         }
 847         return r;
 848 }
 849
 850 long kvm_arch_vcpu_ioctl(struct file *filp,
 851                          unsigned int ioctl, unsigned long arg)
 852 {
 853         struct kvm_vcpu *vcpu = filp->private_data;
 854         void __user *argp = (void __user *)arg;
 855         long r;
 856
 857         switch (ioctl) {
 858         case KVM_S390_INTERRUPT: {
 859                 struct kvm_s390_interrupt s390int;
 860
 861                 r = -EFAULT;
 862                 if (copy_from_user(&s390int, argp, sizeof(s390int)))
 863                         break;
 864                 r = kvm_s390_inject_vcpu(vcpu, &s390int);
 865                 break;
 866         }
 867         case KVM_S390_STORE_STATUS:
 868                 r = kvm_s390_vcpu_store_status(vcpu, arg);
 869                 break;
 870         case KVM_S390_SET_INITIAL_PSW: {
 871                 psw_t psw;
 872
 873                 r = -EFAULT;
 874                 if (copy_from_user(&psw, argp, sizeof(psw)))
 875                         break;
 876                 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
 877                 break;
 878         }
 879         case KVM_S390_INITIAL_RESET:
 880                 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
 881                 break;
 882         case KVM_SET_ONE_REG:
 883         case KVM_GET_ONE_REG: {
 884                 struct kvm_one_reg reg;
 885                 r = -EFAULT;
 886                 if (copy_from_user(&reg, argp, sizeof(reg)))
 887                         break;
 888                 if (ioctl == KVM_SET_ONE_REG)
 889                         r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
 890                 else
 891                         r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
 892                 break;
 893         }
 894 #ifdef CONFIG_KVM_S390_UCONTROL
 895         case KVM_S390_UCAS_MAP: {
 896                 struct kvm_s390_ucas_mapping ucasmap;
 897
 898                 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
 899                         r = -EFAULT;
 900                         break;
 901                 }
 902
 903                 if (!kvm_is_ucontrol(vcpu->kvm)) {
 904                         r = -EINVAL;
 905                         break;
 906                 }
 907
 908                 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
 909                                      ucasmap.vcpu_addr, ucasmap.length);
 910                 break;
 911         }
 912         case KVM_S390_UCAS_UNMAP: {
 913                 struct kvm_s390_ucas_mapping ucasmap;
 914
 915                 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
 916                         r = -EFAULT;
 917                         break;
 918                 }
 919
 920                 if (!kvm_is_ucontrol(vcpu->kvm)) {
 921                         r = -EINVAL;
 922                         break;
 923                 }
 924
 925                 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
 926                         ucasmap.length);
 927                 break;
 928         }
 929 #endif
 930         case KVM_S390_VCPU_FAULT: {
 931                 r = gmap_fault(arg, vcpu->arch.gmap);
 932                 if (!IS_ERR_VALUE(r))
 933                         r = 0;
 934                 break;
 935         }
 936         case KVM_ENABLE_CAP:
 937         {
 938                 struct kvm_enable_cap cap;
 939                 r = -EFAULT;
 940                 if (copy_from_user(&cap, argp, sizeof(cap)))
 941                         break;
 942                 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
 943                 break;
 944         }
 945         default:
 946                 r = -ENOTTY;
 947         }
 948         return r;
 949 }
 950
 951 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
 952 {
 953 #ifdef CONFIG_KVM_S390_UCONTROL
 954         if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
 955                  && (kvm_is_ucontrol(vcpu->kvm))) {
 956                 vmf->page = virt_to_page(vcpu->arch.sie_block);
 957                 get_page(vmf->page);
 958                 return 0;
 959         }
 960 #endif
 961         return VM_FAULT_SIGBUS;
 962 }
 963
 964 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
 965                            struct kvm_memory_slot *dont)
 966 {
 967 }
 968
 969 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
 970 {
 971         return 0;
 972 }
 973
 974 /* Section: memory related */
 975 int kvm_arch_prepare_memory_region(struct kvm *kvm,
 976                                    struct kvm_memory_slot *memslot,
 977                                    struct kvm_userspace_memory_region *mem,
 978                                    enum kvm_mr_change change)
 979 {
 980         /* A few sanity checks. We can have memory slots which have to be
 981            located/ended at a segment boundary (1MB). The memory in userland is
 982            ok to be fragmented into various different vmas. It is okay to mmap()
 983            and munmap() stuff in this slot after doing this call at any time */
 984
 985         if (mem->userspace_addr & 0xffffful)
 986                 return -EINVAL;
 987
 988         if (mem->memory_size & 0xffffful)
 989                 return -EINVAL;
 990
 991         return 0;
 992 }
 993
 994 void kvm_arch_commit_memory_region(struct kvm *kvm,
 995                                 struct kvm_userspace_memory_region *mem,
 996                                 const struct kvm_memory_slot *old,
 997                                 enum kvm_mr_change change)
 998 {
 999         int rc;
1000
1001         /* If the basics of the memslot do not change, we do not want
1002          * to update the gmap. Every update causes several unnecessary
1003          * segment translation exceptions. This is usually handled just
1004          * fine by the normal fault handler + gmap, but it will also
1005          * cause faults on the prefix page of running guest CPUs.
1006          */
1007         if (old->userspace_addr == mem->userspace_addr &&
1008             old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1009             old->npages * PAGE_SIZE == mem->memory_size)
1010                 return;
1011
1012         rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1013                 mem->guest_phys_addr, mem->memory_size);
1014         if (rc)
1015                 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
1016         return;
1017 }
1018
1019 void kvm_arch_flush_shadow_all(struct kvm *kvm)
1020 {
1021 }
1022
1023 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1024                                    struct kvm_memory_slot *slot)
1025 {
1026 }
1027
1028 static int __init kvm_s390_init(void)
1029 {
1030         int ret;
1031         ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1032         if (ret)
1033                 return ret;
1034
1035         /*
1036          * guests can ask for up to 255+1 double words, we need a full page
1037          * to hold the maximum amount of facilities. On the other hand, we
1038          * only set facilities that are known to work in KVM.
1039          */
1040         facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1041         if (!facilities) {
1042                 kvm_exit();
1043                 return -ENOMEM;
1044         }
1045         memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
1046         facilities[0] &= 0xff00fff3f47c0000ULL;
1047         facilities[1] &= 0x001c000000000000ULL;
1048         return 0;
1049 }
1050
1051 static void __exit kvm_s390_exit(void)
1052 {
1053         free_page((unsigned long) facilities);
1054         kvm_exit();
1055 }
1056
1057 module_init(kvm_s390_init);
1058 module_exit(kvm_s390_exit);