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