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