arch/s390/kvm/kvm-s390.c

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