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