2 * hosting zSeries kernel virtual machines
4 * Copyright IBM Corp. 2008, 2009
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.
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>
16 #include <linux/compiler.h>
17 #include <linux/err.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>
30 #include <asm/switch_to.h>
35 #define CREATE_TRACE_POINTS
37 #include "trace-s390.h"
39 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
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) },
86 static unsigned long long *facilities;
88 /* Section: not file related */
89 int kvm_arch_hardware_enable(void *garbage)
91 /* every s390 is virtualization enabled ;-) */
95 void kvm_arch_hardware_disable(void *garbage)
99 int kvm_arch_hardware_setup(void)
104 void kvm_arch_hardware_unsetup(void)
108 void kvm_arch_check_processor_compat(void *rtn)
112 int kvm_arch_init(void *opaque)
117 void kvm_arch_exit(void)
121 /* Section: device related */
122 long kvm_arch_dev_ioctl(struct file *filp,
123 unsigned int ioctl, unsigned long arg)
125 if (ioctl == KVM_S390_ENABLE_SIE)
126 return s390_enable_sie();
130 int kvm_dev_ioctl_check_extension(long 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:
141 case KVM_CAP_SYNC_REGS:
142 case KVM_CAP_ONE_REG:
143 case KVM_CAP_ENABLE_CAP:
146 case KVM_CAP_NR_VCPUS:
147 case KVM_CAP_MAX_VCPUS:
150 case KVM_CAP_S390_COW:
151 r = sclp_get_fac85() & 0x2;
159 /* Section: vm related */
161 * Get (and clear) the dirty memory log for a memory slot.
163 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
164 struct kvm_dirty_log *log)
169 long kvm_arch_vm_ioctl(struct file *filp,
170 unsigned int ioctl, unsigned long arg)
172 struct kvm *kvm = filp->private_data;
173 void __user *argp = (void __user *)arg;
177 case KVM_S390_INTERRUPT: {
178 struct kvm_s390_interrupt s390int;
181 if (copy_from_user(&s390int, argp, sizeof(s390int)))
183 r = kvm_s390_inject_vm(kvm, &s390int);
193 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
199 #ifdef CONFIG_KVM_S390_UCONTROL
200 if (type & ~KVM_VM_S390_UCONTROL)
202 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
209 rc = s390_enable_sie();
215 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
219 sprintf(debug_name, "kvm-%u", current->pid);
221 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
225 spin_lock_init(&kvm->arch.float_int.lock);
226 INIT_LIST_HEAD(&kvm->arch.float_int.list);
228 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
229 VM_EVENT(kvm, 3, "%s", "vm created");
231 if (type & KVM_VM_S390_UCONTROL) {
232 kvm->arch.gmap = NULL;
234 kvm->arch.gmap = gmap_alloc(current->mm);
240 debug_unregister(kvm->arch.dbf);
242 free_page((unsigned long)(kvm->arch.sca));
247 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
249 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
250 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
251 if (!kvm_is_ucontrol(vcpu->kvm)) {
252 clear_bit(63 - vcpu->vcpu_id,
253 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
254 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
255 (__u64) vcpu->arch.sie_block)
256 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
260 if (kvm_is_ucontrol(vcpu->kvm))
261 gmap_free(vcpu->arch.gmap);
263 free_page((unsigned long)(vcpu->arch.sie_block));
264 kvm_vcpu_uninit(vcpu);
268 static void kvm_free_vcpus(struct kvm *kvm)
271 struct kvm_vcpu *vcpu;
273 kvm_for_each_vcpu(i, vcpu, kvm)
274 kvm_arch_vcpu_destroy(vcpu);
276 mutex_lock(&kvm->lock);
277 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
278 kvm->vcpus[i] = NULL;
280 atomic_set(&kvm->online_vcpus, 0);
281 mutex_unlock(&kvm->lock);
284 void kvm_arch_sync_events(struct kvm *kvm)
288 void kvm_arch_destroy_vm(struct kvm *kvm)
291 free_page((unsigned long)(kvm->arch.sca));
292 debug_unregister(kvm->arch.dbf);
293 if (!kvm_is_ucontrol(kvm))
294 gmap_free(kvm->arch.gmap);
297 /* Section: vcpu related */
298 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
300 if (kvm_is_ucontrol(vcpu->kvm)) {
301 vcpu->arch.gmap = gmap_alloc(current->mm);
302 if (!vcpu->arch.gmap)
307 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
308 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
315 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
320 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
322 save_fp_regs(&vcpu->arch.host_fpregs);
323 save_access_regs(vcpu->arch.host_acrs);
324 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
325 restore_fp_regs(&vcpu->arch.guest_fpregs);
326 restore_access_regs(vcpu->run->s.regs.acrs);
327 gmap_enable(vcpu->arch.gmap);
328 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
331 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
333 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
334 gmap_disable(vcpu->arch.gmap);
335 save_fp_regs(&vcpu->arch.guest_fpregs);
336 save_access_regs(vcpu->run->s.regs.acrs);
337 restore_fp_regs(&vcpu->arch.host_fpregs);
338 restore_access_regs(vcpu->arch.host_acrs);
341 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
343 /* this equals initial cpu reset in pop, but we don't switch to ESA */
344 vcpu->arch.sie_block->gpsw.mask = 0UL;
345 vcpu->arch.sie_block->gpsw.addr = 0UL;
346 kvm_s390_set_prefix(vcpu, 0);
347 vcpu->arch.sie_block->cputm = 0UL;
348 vcpu->arch.sie_block->ckc = 0UL;
349 vcpu->arch.sie_block->todpr = 0;
350 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
351 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
352 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
353 vcpu->arch.guest_fpregs.fpc = 0;
354 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
355 vcpu->arch.sie_block->gbea = 1;
356 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
359 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
364 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
366 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
369 vcpu->arch.sie_block->ecb = 6;
370 vcpu->arch.sie_block->eca = 0xC1002001U;
371 vcpu->arch.sie_block->fac = (int) (long) facilities;
372 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
373 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
374 (unsigned long) vcpu);
375 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
376 get_cpu_id(&vcpu->arch.cpu_id);
377 vcpu->arch.cpu_id.version = 0xff;
381 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
384 struct kvm_vcpu *vcpu;
387 if (id >= KVM_MAX_VCPUS)
392 vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
396 vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
397 get_zeroed_page(GFP_KERNEL);
399 if (!vcpu->arch.sie_block)
402 vcpu->arch.sie_block->icpua = id;
403 if (!kvm_is_ucontrol(kvm)) {
404 if (!kvm->arch.sca) {
408 if (!kvm->arch.sca->cpu[id].sda)
409 kvm->arch.sca->cpu[id].sda =
410 (__u64) vcpu->arch.sie_block;
411 vcpu->arch.sie_block->scaoh =
412 (__u32)(((__u64)kvm->arch.sca) >> 32);
413 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
414 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
417 spin_lock_init(&vcpu->arch.local_int.lock);
418 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
419 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
420 spin_lock(&kvm->arch.float_int.lock);
421 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
422 init_waitqueue_head(&vcpu->arch.local_int.wq);
423 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
424 spin_unlock(&kvm->arch.float_int.lock);
426 rc = kvm_vcpu_init(vcpu, kvm, id);
428 goto out_free_sie_block;
429 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
430 vcpu->arch.sie_block);
431 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
435 free_page((unsigned long)(vcpu->arch.sie_block));
442 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
444 /* kvm common code refers to this, but never calls it */
449 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
451 /* kvm common code refers to this, but never calls it */
456 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
457 struct kvm_one_reg *reg)
462 case KVM_REG_S390_TODPR:
463 r = put_user(vcpu->arch.sie_block->todpr,
464 (u32 __user *)reg->addr);
466 case KVM_REG_S390_EPOCHDIFF:
467 r = put_user(vcpu->arch.sie_block->epoch,
468 (u64 __user *)reg->addr);
470 case KVM_REG_S390_CPU_TIMER:
471 r = put_user(vcpu->arch.sie_block->cputm,
472 (u64 __user *)reg->addr);
474 case KVM_REG_S390_CLOCK_COMP:
475 r = put_user(vcpu->arch.sie_block->ckc,
476 (u64 __user *)reg->addr);
485 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
486 struct kvm_one_reg *reg)
491 case KVM_REG_S390_TODPR:
492 r = get_user(vcpu->arch.sie_block->todpr,
493 (u32 __user *)reg->addr);
495 case KVM_REG_S390_EPOCHDIFF:
496 r = get_user(vcpu->arch.sie_block->epoch,
497 (u64 __user *)reg->addr);
499 case KVM_REG_S390_CPU_TIMER:
500 r = get_user(vcpu->arch.sie_block->cputm,
501 (u64 __user *)reg->addr);
503 case KVM_REG_S390_CLOCK_COMP:
504 r = get_user(vcpu->arch.sie_block->ckc,
505 (u64 __user *)reg->addr);
514 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
516 kvm_s390_vcpu_initial_reset(vcpu);
520 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
522 memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs));
526 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
528 memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
532 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
533 struct kvm_sregs *sregs)
535 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
536 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
537 restore_access_regs(vcpu->run->s.regs.acrs);
541 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
542 struct kvm_sregs *sregs)
544 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
545 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
549 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
551 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
552 vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK;
553 restore_fp_regs(&vcpu->arch.guest_fpregs);
557 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
559 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
560 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
564 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
568 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
571 vcpu->run->psw_mask = psw.mask;
572 vcpu->run->psw_addr = psw.addr;
577 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
578 struct kvm_translation *tr)
580 return -EINVAL; /* not implemented yet */
583 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
584 struct kvm_guest_debug *dbg)
586 return -EINVAL; /* not implemented yet */
589 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
590 struct kvm_mp_state *mp_state)
592 return -EINVAL; /* not implemented yet */
595 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
596 struct kvm_mp_state *mp_state)
598 return -EINVAL; /* not implemented yet */
601 static int __vcpu_run(struct kvm_vcpu *vcpu)
605 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
610 if (test_thread_flag(TIF_MCCK_PENDING))
613 if (!kvm_is_ucontrol(vcpu->kvm))
614 kvm_s390_deliver_pending_interrupts(vcpu);
616 vcpu->arch.sie_block->icptcode = 0;
618 VCPU_EVENT(vcpu, 6, "entering sie flags %x",
619 atomic_read(&vcpu->arch.sie_block->cpuflags));
620 trace_kvm_s390_sie_enter(vcpu,
621 atomic_read(&vcpu->arch.sie_block->cpuflags));
622 rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
624 if (kvm_is_ucontrol(vcpu->kvm)) {
625 rc = SIE_INTERCEPT_UCONTROL;
627 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
628 trace_kvm_s390_sie_fault(vcpu);
629 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
633 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
634 vcpu->arch.sie_block->icptcode);
635 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
638 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
642 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
648 if (vcpu->sigset_active)
649 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
651 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
653 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
655 switch (kvm_run->exit_reason) {
656 case KVM_EXIT_S390_SIEIC:
657 case KVM_EXIT_UNKNOWN:
659 case KVM_EXIT_S390_RESET:
660 case KVM_EXIT_S390_UCONTROL:
666 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
667 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
668 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
669 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
670 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
672 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
673 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
674 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
675 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
681 rc = __vcpu_run(vcpu);
684 if (kvm_is_ucontrol(vcpu->kvm))
687 rc = kvm_handle_sie_intercept(vcpu);
688 } while (!signal_pending(current) && !rc);
690 if (rc == SIE_INTERCEPT_RERUNVCPU)
693 if (signal_pending(current) && !rc) {
694 kvm_run->exit_reason = KVM_EXIT_INTR;
698 #ifdef CONFIG_KVM_S390_UCONTROL
699 if (rc == SIE_INTERCEPT_UCONTROL) {
700 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
701 kvm_run->s390_ucontrol.trans_exc_code =
702 current->thread.gmap_addr;
703 kvm_run->s390_ucontrol.pgm_code = 0x10;
708 if (rc == -EOPNOTSUPP) {
709 /* intercept cannot be handled in-kernel, prepare kvm-run */
710 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
711 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
712 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
713 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
717 if (rc == -EREMOTE) {
718 /* intercept was handled, but userspace support is needed
719 * kvm_run has been prepared by the handler */
723 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
724 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
725 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
726 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
728 if (vcpu->sigset_active)
729 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
731 vcpu->stat.exit_userspace++;
735 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
736 unsigned long n, int prefix)
739 return copy_to_guest(vcpu, guestdest, from, n);
741 return copy_to_guest_absolute(vcpu, guestdest, from, n);
745 * store status at address
746 * we use have two special cases:
747 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
748 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
750 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
752 unsigned char archmode = 1;
755 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
756 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
758 addr = SAVE_AREA_BASE;
760 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
761 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
763 addr = SAVE_AREA_BASE;
768 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
769 vcpu->arch.guest_fpregs.fprs, 128, prefix))
772 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
773 vcpu->run->s.regs.gprs, 128, prefix))
776 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
777 &vcpu->arch.sie_block->gpsw, 16, prefix))
780 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
781 &vcpu->arch.sie_block->prefix, 4, prefix))
784 if (__guestcopy(vcpu,
785 addr + offsetof(struct save_area, fp_ctrl_reg),
786 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
789 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
790 &vcpu->arch.sie_block->todpr, 4, prefix))
793 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
794 &vcpu->arch.sie_block->cputm, 8, prefix))
797 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
798 &vcpu->arch.sie_block->ckc, 8, prefix))
801 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
802 &vcpu->run->s.regs.acrs, 64, prefix))
805 if (__guestcopy(vcpu,
806 addr + offsetof(struct save_area, ctrl_regs),
807 &vcpu->arch.sie_block->gcr, 128, prefix))
812 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
813 struct kvm_enable_cap *cap)
828 long kvm_arch_vcpu_ioctl(struct file *filp,
829 unsigned int ioctl, unsigned long arg)
831 struct kvm_vcpu *vcpu = filp->private_data;
832 void __user *argp = (void __user *)arg;
836 case KVM_S390_INTERRUPT: {
837 struct kvm_s390_interrupt s390int;
840 if (copy_from_user(&s390int, argp, sizeof(s390int)))
842 r = kvm_s390_inject_vcpu(vcpu, &s390int);
845 case KVM_S390_STORE_STATUS:
846 r = kvm_s390_vcpu_store_status(vcpu, arg);
848 case KVM_S390_SET_INITIAL_PSW: {
852 if (copy_from_user(&psw, argp, sizeof(psw)))
854 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
857 case KVM_S390_INITIAL_RESET:
858 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
860 case KVM_SET_ONE_REG:
861 case KVM_GET_ONE_REG: {
862 struct kvm_one_reg reg;
864 if (copy_from_user(®, argp, sizeof(reg)))
866 if (ioctl == KVM_SET_ONE_REG)
867 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®);
869 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®);
872 #ifdef CONFIG_KVM_S390_UCONTROL
873 case KVM_S390_UCAS_MAP: {
874 struct kvm_s390_ucas_mapping ucasmap;
876 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
881 if (!kvm_is_ucontrol(vcpu->kvm)) {
886 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
887 ucasmap.vcpu_addr, ucasmap.length);
890 case KVM_S390_UCAS_UNMAP: {
891 struct kvm_s390_ucas_mapping ucasmap;
893 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
898 if (!kvm_is_ucontrol(vcpu->kvm)) {
903 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
908 case KVM_S390_VCPU_FAULT: {
909 r = gmap_fault(arg, vcpu->arch.gmap);
910 if (!IS_ERR_VALUE(r))
916 struct kvm_enable_cap cap;
918 if (copy_from_user(&cap, argp, sizeof(cap)))
920 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
929 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
931 #ifdef CONFIG_KVM_S390_UCONTROL
932 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
933 && (kvm_is_ucontrol(vcpu->kvm))) {
934 vmf->page = virt_to_page(vcpu->arch.sie_block);
939 return VM_FAULT_SIGBUS;
942 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
943 struct kvm_memory_slot *dont)
947 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
952 /* Section: memory related */
953 int kvm_arch_prepare_memory_region(struct kvm *kvm,
954 struct kvm_memory_slot *memslot,
955 struct kvm_memory_slot old,
956 struct kvm_userspace_memory_region *mem,
959 /* A few sanity checks. We can have exactly one memory slot which has
960 to start at guest virtual zero and which has to be located at a
961 page boundary in userland and which has to end at a page boundary.
962 The memory in userland is ok to be fragmented into various different
963 vmas. It is okay to mmap() and munmap() stuff in this slot after
964 doing this call at any time */
969 if (mem->guest_phys_addr)
972 if (mem->userspace_addr & 0xffffful)
975 if (mem->memory_size & 0xffffful)
984 void kvm_arch_commit_memory_region(struct kvm *kvm,
985 struct kvm_userspace_memory_region *mem,
986 struct kvm_memory_slot old,
992 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
993 mem->guest_phys_addr, mem->memory_size);
995 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
999 void kvm_arch_flush_shadow_all(struct kvm *kvm)
1003 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1004 struct kvm_memory_slot *slot)
1008 static int __init kvm_s390_init(void)
1011 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1016 * guests can ask for up to 255+1 double words, we need a full page
1017 * to hold the maximum amount of facilities. On the other hand, we
1018 * only set facilities that are known to work in KVM.
1020 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1025 memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
1026 facilities[0] &= 0xff00fff3f47c0000ULL;
1027 facilities[1] &= 0x001c000000000000ULL;
1031 static void __exit kvm_s390_exit(void)
1033 free_page((unsigned long) facilities);
1037 module_init(kvm_s390_init);
1038 module_exit(kvm_s390_exit);