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