arch/s390/kvm/kvm-s390.c

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