arch/s390/kvm/kvm-s390.c

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