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_pfmf", VCPU_STAT(instruction_pfmf) },
63 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
64 { "instruction_spx", VCPU_STAT(instruction_spx) },
65 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
66 { "instruction_stap", VCPU_STAT(instruction_stap) },
67 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
68 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
69 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
70 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
71 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
72 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
73 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
74 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
75 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
76 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
77 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
78 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
79 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
80 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
81 { "diagnose_10", VCPU_STAT(diagnose_10) },
82 { "diagnose_44", VCPU_STAT(diagnose_44) },
83 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
87 static unsigned long long *facilities;
88 static struct gmap_notifier gmap_notifier;
90 /* Section: not file related */
91 int kvm_arch_hardware_enable(void *garbage)
93 /* every s390 is virtualization enabled ;-) */
97 void kvm_arch_hardware_disable(void *garbage)
101 static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
103 int kvm_arch_hardware_setup(void)
105 gmap_notifier.notifier_call = kvm_gmap_notifier;
106 gmap_register_ipte_notifier(&gmap_notifier);
110 void kvm_arch_hardware_unsetup(void)
112 gmap_unregister_ipte_notifier(&gmap_notifier);
115 void kvm_arch_check_processor_compat(void *rtn)
119 int kvm_arch_init(void *opaque)
124 void kvm_arch_exit(void)
128 /* Section: device related */
129 long kvm_arch_dev_ioctl(struct file *filp,
130 unsigned int ioctl, unsigned long arg)
132 if (ioctl == KVM_S390_ENABLE_SIE)
133 return s390_enable_sie();
137 int kvm_dev_ioctl_check_extension(long ext)
142 case KVM_CAP_S390_PSW:
143 case KVM_CAP_S390_GMAP:
144 case KVM_CAP_SYNC_MMU:
145 #ifdef CONFIG_KVM_S390_UCONTROL
146 case KVM_CAP_S390_UCONTROL:
148 case KVM_CAP_SYNC_REGS:
149 case KVM_CAP_ONE_REG:
150 case KVM_CAP_ENABLE_CAP:
151 case KVM_CAP_S390_CSS_SUPPORT:
152 case KVM_CAP_IOEVENTFD:
155 case KVM_CAP_NR_VCPUS:
156 case KVM_CAP_MAX_VCPUS:
159 case KVM_CAP_NR_MEMSLOTS:
160 r = KVM_USER_MEM_SLOTS;
162 case KVM_CAP_S390_COW:
163 r = MACHINE_HAS_ESOP;
171 /* Section: vm related */
173 * Get (and clear) the dirty memory log for a memory slot.
175 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
176 struct kvm_dirty_log *log)
181 long kvm_arch_vm_ioctl(struct file *filp,
182 unsigned int ioctl, unsigned long arg)
184 struct kvm *kvm = filp->private_data;
185 void __user *argp = (void __user *)arg;
189 case KVM_S390_INTERRUPT: {
190 struct kvm_s390_interrupt s390int;
193 if (copy_from_user(&s390int, argp, sizeof(s390int)))
195 r = kvm_s390_inject_vm(kvm, &s390int);
205 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
211 #ifdef CONFIG_KVM_S390_UCONTROL
212 if (type & ~KVM_VM_S390_UCONTROL)
214 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
221 rc = s390_enable_sie();
227 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
231 sprintf(debug_name, "kvm-%u", current->pid);
233 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
237 spin_lock_init(&kvm->arch.float_int.lock);
238 INIT_LIST_HEAD(&kvm->arch.float_int.list);
240 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
241 VM_EVENT(kvm, 3, "%s", "vm created");
243 if (type & KVM_VM_S390_UCONTROL) {
244 kvm->arch.gmap = NULL;
246 kvm->arch.gmap = gmap_alloc(current->mm);
249 kvm->arch.gmap->private = kvm;
252 kvm->arch.css_support = 0;
256 debug_unregister(kvm->arch.dbf);
258 free_page((unsigned long)(kvm->arch.sca));
263 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
265 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
266 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
267 if (!kvm_is_ucontrol(vcpu->kvm)) {
268 clear_bit(63 - vcpu->vcpu_id,
269 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
270 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
271 (__u64) vcpu->arch.sie_block)
272 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
276 if (kvm_is_ucontrol(vcpu->kvm))
277 gmap_free(vcpu->arch.gmap);
279 free_page((unsigned long)(vcpu->arch.sie_block));
280 kvm_vcpu_uninit(vcpu);
281 kmem_cache_free(kvm_vcpu_cache, vcpu);
284 static void kvm_free_vcpus(struct kvm *kvm)
287 struct kvm_vcpu *vcpu;
289 kvm_for_each_vcpu(i, vcpu, kvm)
290 kvm_arch_vcpu_destroy(vcpu);
292 mutex_lock(&kvm->lock);
293 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
294 kvm->vcpus[i] = NULL;
296 atomic_set(&kvm->online_vcpus, 0);
297 mutex_unlock(&kvm->lock);
300 void kvm_arch_sync_events(struct kvm *kvm)
304 void kvm_arch_destroy_vm(struct kvm *kvm)
307 free_page((unsigned long)(kvm->arch.sca));
308 debug_unregister(kvm->arch.dbf);
309 if (!kvm_is_ucontrol(kvm))
310 gmap_free(kvm->arch.gmap);
313 /* Section: vcpu related */
314 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
316 if (kvm_is_ucontrol(vcpu->kvm)) {
317 vcpu->arch.gmap = gmap_alloc(current->mm);
318 if (!vcpu->arch.gmap)
320 vcpu->arch.gmap->private = vcpu->kvm;
324 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
325 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
332 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
337 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
339 save_fp_regs(&vcpu->arch.host_fpregs);
340 save_access_regs(vcpu->arch.host_acrs);
341 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
342 restore_fp_regs(&vcpu->arch.guest_fpregs);
343 restore_access_regs(vcpu->run->s.regs.acrs);
344 gmap_enable(vcpu->arch.gmap);
345 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
348 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
350 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
351 gmap_disable(vcpu->arch.gmap);
352 save_fp_regs(&vcpu->arch.guest_fpregs);
353 save_access_regs(vcpu->run->s.regs.acrs);
354 restore_fp_regs(&vcpu->arch.host_fpregs);
355 restore_access_regs(vcpu->arch.host_acrs);
358 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
360 /* this equals initial cpu reset in pop, but we don't switch to ESA */
361 vcpu->arch.sie_block->gpsw.mask = 0UL;
362 vcpu->arch.sie_block->gpsw.addr = 0UL;
363 kvm_s390_set_prefix(vcpu, 0);
364 vcpu->arch.sie_block->cputm = 0UL;
365 vcpu->arch.sie_block->ckc = 0UL;
366 vcpu->arch.sie_block->todpr = 0;
367 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
368 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
369 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
370 vcpu->arch.guest_fpregs.fpc = 0;
371 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
372 vcpu->arch.sie_block->gbea = 1;
373 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
376 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
381 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
383 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
387 vcpu->arch.sie_block->ecb = 6;
388 vcpu->arch.sie_block->ecb2 = 8;
389 vcpu->arch.sie_block->eca = 0xC1002001U;
390 vcpu->arch.sie_block->fac = (int) (long) facilities;
391 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
392 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
393 (unsigned long) vcpu);
394 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
395 get_cpu_id(&vcpu->arch.cpu_id);
396 vcpu->arch.cpu_id.version = 0xff;
400 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
403 struct kvm_vcpu *vcpu;
406 if (id >= KVM_MAX_VCPUS)
411 vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
415 vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
416 get_zeroed_page(GFP_KERNEL);
418 if (!vcpu->arch.sie_block)
421 vcpu->arch.sie_block->icpua = id;
422 if (!kvm_is_ucontrol(kvm)) {
423 if (!kvm->arch.sca) {
427 if (!kvm->arch.sca->cpu[id].sda)
428 kvm->arch.sca->cpu[id].sda =
429 (__u64) vcpu->arch.sie_block;
430 vcpu->arch.sie_block->scaoh =
431 (__u32)(((__u64)kvm->arch.sca) >> 32);
432 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
433 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
436 spin_lock_init(&vcpu->arch.local_int.lock);
437 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
438 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
439 spin_lock(&kvm->arch.float_int.lock);
440 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
441 vcpu->arch.local_int.wq = &vcpu->wq;
442 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
443 spin_unlock(&kvm->arch.float_int.lock);
445 rc = kvm_vcpu_init(vcpu, kvm, id);
447 goto out_free_sie_block;
448 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
449 vcpu->arch.sie_block);
450 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
454 free_page((unsigned long)(vcpu->arch.sie_block));
456 kmem_cache_free(kvm_vcpu_cache, vcpu);
461 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
463 /* kvm common code refers to this, but never calls it */
468 void s390_vcpu_block(struct kvm_vcpu *vcpu)
470 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
473 void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
475 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
479 * Kick a guest cpu out of SIE and wait until SIE is not running.
480 * If the CPU is not running (e.g. waiting as idle) the function will
481 * return immediately. */
482 void exit_sie(struct kvm_vcpu *vcpu)
484 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
485 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
489 /* Kick a guest cpu out of SIE and prevent SIE-reentry */
490 void exit_sie_sync(struct kvm_vcpu *vcpu)
492 s390_vcpu_block(vcpu);
496 static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
499 struct kvm *kvm = gmap->private;
500 struct kvm_vcpu *vcpu;
502 kvm_for_each_vcpu(i, vcpu, kvm) {
503 /* match against both prefix pages */
504 if (vcpu->arch.sie_block->prefix == (address & ~0x1000UL)) {
505 VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
506 kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
512 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
514 /* kvm common code refers to this, but never calls it */
519 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
520 struct kvm_one_reg *reg)
525 case KVM_REG_S390_TODPR:
526 r = put_user(vcpu->arch.sie_block->todpr,
527 (u32 __user *)reg->addr);
529 case KVM_REG_S390_EPOCHDIFF:
530 r = put_user(vcpu->arch.sie_block->epoch,
531 (u64 __user *)reg->addr);
533 case KVM_REG_S390_CPU_TIMER:
534 r = put_user(vcpu->arch.sie_block->cputm,
535 (u64 __user *)reg->addr);
537 case KVM_REG_S390_CLOCK_COMP:
538 r = put_user(vcpu->arch.sie_block->ckc,
539 (u64 __user *)reg->addr);
548 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
549 struct kvm_one_reg *reg)
554 case KVM_REG_S390_TODPR:
555 r = get_user(vcpu->arch.sie_block->todpr,
556 (u32 __user *)reg->addr);
558 case KVM_REG_S390_EPOCHDIFF:
559 r = get_user(vcpu->arch.sie_block->epoch,
560 (u64 __user *)reg->addr);
562 case KVM_REG_S390_CPU_TIMER:
563 r = get_user(vcpu->arch.sie_block->cputm,
564 (u64 __user *)reg->addr);
566 case KVM_REG_S390_CLOCK_COMP:
567 r = get_user(vcpu->arch.sie_block->ckc,
568 (u64 __user *)reg->addr);
577 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
579 kvm_s390_vcpu_initial_reset(vcpu);
583 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
585 memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs));
589 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
591 memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
595 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
596 struct kvm_sregs *sregs)
598 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
599 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
600 restore_access_regs(vcpu->run->s.regs.acrs);
604 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
605 struct kvm_sregs *sregs)
607 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
608 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
612 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
614 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
615 vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK;
616 restore_fp_regs(&vcpu->arch.guest_fpregs);
620 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
622 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
623 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
627 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
631 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
634 vcpu->run->psw_mask = psw.mask;
635 vcpu->run->psw_addr = psw.addr;
640 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
641 struct kvm_translation *tr)
643 return -EINVAL; /* not implemented yet */
646 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
647 struct kvm_guest_debug *dbg)
649 return -EINVAL; /* not implemented yet */
652 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
653 struct kvm_mp_state *mp_state)
655 return -EINVAL; /* not implemented yet */
658 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
659 struct kvm_mp_state *mp_state)
661 return -EINVAL; /* not implemented yet */
664 static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
667 * We use MMU_RELOAD just to re-arm the ipte notifier for the
668 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
669 * This ensures that the ipte instruction for this request has
670 * already finished. We might race against a second unmapper that
671 * wants to set the blocking bit. Lets just retry the request loop.
673 while (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
675 rc = gmap_ipte_notify(vcpu->arch.gmap,
676 vcpu->arch.sie_block->prefix,
680 s390_vcpu_unblock(vcpu);
685 static int __vcpu_run(struct kvm_vcpu *vcpu)
689 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
694 if (test_thread_flag(TIF_MCCK_PENDING))
697 if (!kvm_is_ucontrol(vcpu->kvm))
698 kvm_s390_deliver_pending_interrupts(vcpu);
700 rc = kvm_s390_handle_requests(vcpu);
704 vcpu->arch.sie_block->icptcode = 0;
708 VCPU_EVENT(vcpu, 6, "entering sie flags %x",
709 atomic_read(&vcpu->arch.sie_block->cpuflags));
710 trace_kvm_s390_sie_enter(vcpu,
711 atomic_read(&vcpu->arch.sie_block->cpuflags));
712 rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
716 if (kvm_is_ucontrol(vcpu->kvm)) {
717 rc = SIE_INTERCEPT_UCONTROL;
719 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
720 trace_kvm_s390_sie_fault(vcpu);
721 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
724 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
725 vcpu->arch.sie_block->icptcode);
726 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
729 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
733 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
739 if (vcpu->sigset_active)
740 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
742 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
744 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
746 switch (kvm_run->exit_reason) {
747 case KVM_EXIT_S390_SIEIC:
748 case KVM_EXIT_UNKNOWN:
750 case KVM_EXIT_S390_RESET:
751 case KVM_EXIT_S390_UCONTROL:
752 case KVM_EXIT_S390_TSCH:
758 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
759 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
760 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
761 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
762 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
764 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
765 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
766 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
767 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
773 rc = __vcpu_run(vcpu);
776 if (kvm_is_ucontrol(vcpu->kvm))
779 rc = kvm_handle_sie_intercept(vcpu);
780 } while (!signal_pending(current) && !rc);
782 if (rc == SIE_INTERCEPT_RERUNVCPU)
785 if (signal_pending(current) && !rc) {
786 kvm_run->exit_reason = KVM_EXIT_INTR;
790 #ifdef CONFIG_KVM_S390_UCONTROL
791 if (rc == SIE_INTERCEPT_UCONTROL) {
792 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
793 kvm_run->s390_ucontrol.trans_exc_code =
794 current->thread.gmap_addr;
795 kvm_run->s390_ucontrol.pgm_code = 0x10;
800 if (rc == -EOPNOTSUPP) {
801 /* intercept cannot be handled in-kernel, prepare kvm-run */
802 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
803 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
804 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
805 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
809 if (rc == -EREMOTE) {
810 /* intercept was handled, but userspace support is needed
811 * kvm_run has been prepared by the handler */
815 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
816 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
817 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
818 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
820 if (vcpu->sigset_active)
821 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
823 vcpu->stat.exit_userspace++;
827 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
828 unsigned long n, int prefix)
831 return copy_to_guest(vcpu, guestdest, from, n);
833 return copy_to_guest_absolute(vcpu, guestdest, from, n);
837 * store status at address
838 * we use have two special cases:
839 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
840 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
842 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
844 unsigned char archmode = 1;
847 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
848 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
850 addr = SAVE_AREA_BASE;
852 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
853 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
855 addr = SAVE_AREA_BASE;
861 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
862 * copying in vcpu load/put. Lets update our copies before we save
863 * it into the save area
865 save_fp_regs(&vcpu->arch.guest_fpregs);
866 save_access_regs(vcpu->run->s.regs.acrs);
868 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
869 vcpu->arch.guest_fpregs.fprs, 128, prefix))
872 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
873 vcpu->run->s.regs.gprs, 128, prefix))
876 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
877 &vcpu->arch.sie_block->gpsw, 16, prefix))
880 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
881 &vcpu->arch.sie_block->prefix, 4, prefix))
884 if (__guestcopy(vcpu,
885 addr + offsetof(struct save_area, fp_ctrl_reg),
886 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
889 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
890 &vcpu->arch.sie_block->todpr, 4, prefix))
893 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
894 &vcpu->arch.sie_block->cputm, 8, prefix))
897 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
898 &vcpu->arch.sie_block->ckc, 8, prefix))
901 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
902 &vcpu->run->s.regs.acrs, 64, prefix))
905 if (__guestcopy(vcpu,
906 addr + offsetof(struct save_area, ctrl_regs),
907 &vcpu->arch.sie_block->gcr, 128, prefix))
912 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
913 struct kvm_enable_cap *cap)
921 case KVM_CAP_S390_CSS_SUPPORT:
922 if (!vcpu->kvm->arch.css_support) {
923 vcpu->kvm->arch.css_support = 1;
924 trace_kvm_s390_enable_css(vcpu->kvm);
935 long kvm_arch_vcpu_ioctl(struct file *filp,
936 unsigned int ioctl, unsigned long arg)
938 struct kvm_vcpu *vcpu = filp->private_data;
939 void __user *argp = (void __user *)arg;
943 case KVM_S390_INTERRUPT: {
944 struct kvm_s390_interrupt s390int;
947 if (copy_from_user(&s390int, argp, sizeof(s390int)))
949 r = kvm_s390_inject_vcpu(vcpu, &s390int);
952 case KVM_S390_STORE_STATUS:
953 r = kvm_s390_vcpu_store_status(vcpu, arg);
955 case KVM_S390_SET_INITIAL_PSW: {
959 if (copy_from_user(&psw, argp, sizeof(psw)))
961 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
964 case KVM_S390_INITIAL_RESET:
965 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
967 case KVM_SET_ONE_REG:
968 case KVM_GET_ONE_REG: {
969 struct kvm_one_reg reg;
971 if (copy_from_user(®, argp, sizeof(reg)))
973 if (ioctl == KVM_SET_ONE_REG)
974 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®);
976 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®);
979 #ifdef CONFIG_KVM_S390_UCONTROL
980 case KVM_S390_UCAS_MAP: {
981 struct kvm_s390_ucas_mapping ucasmap;
983 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
988 if (!kvm_is_ucontrol(vcpu->kvm)) {
993 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
994 ucasmap.vcpu_addr, ucasmap.length);
997 case KVM_S390_UCAS_UNMAP: {
998 struct kvm_s390_ucas_mapping ucasmap;
1000 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1005 if (!kvm_is_ucontrol(vcpu->kvm)) {
1010 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
1015 case KVM_S390_VCPU_FAULT: {
1016 r = gmap_fault(arg, vcpu->arch.gmap);
1017 if (!IS_ERR_VALUE(r))
1021 case KVM_ENABLE_CAP:
1023 struct kvm_enable_cap cap;
1025 if (copy_from_user(&cap, argp, sizeof(cap)))
1027 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1036 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1038 #ifdef CONFIG_KVM_S390_UCONTROL
1039 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
1040 && (kvm_is_ucontrol(vcpu->kvm))) {
1041 vmf->page = virt_to_page(vcpu->arch.sie_block);
1042 get_page(vmf->page);
1046 return VM_FAULT_SIGBUS;
1049 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
1050 struct kvm_memory_slot *dont)
1054 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
1059 void kvm_arch_memslots_updated(struct kvm *kvm)
1063 /* Section: memory related */
1064 int kvm_arch_prepare_memory_region(struct kvm *kvm,
1065 struct kvm_memory_slot *memslot,
1066 struct kvm_userspace_memory_region *mem,
1067 enum kvm_mr_change change)
1069 /* A few sanity checks. We can have memory slots which have to be
1070 located/ended at a segment boundary (1MB). The memory in userland is
1071 ok to be fragmented into various different vmas. It is okay to mmap()
1072 and munmap() stuff in this slot after doing this call at any time */
1074 if (mem->userspace_addr & 0xffffful)
1077 if (mem->memory_size & 0xffffful)
1083 void kvm_arch_commit_memory_region(struct kvm *kvm,
1084 struct kvm_userspace_memory_region *mem,
1085 const struct kvm_memory_slot *old,
1086 enum kvm_mr_change change)
1090 /* If the basics of the memslot do not change, we do not want
1091 * to update the gmap. Every update causes several unnecessary
1092 * segment translation exceptions. This is usually handled just
1093 * fine by the normal fault handler + gmap, but it will also
1094 * cause faults on the prefix page of running guest CPUs.
1096 if (old->userspace_addr == mem->userspace_addr &&
1097 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1098 old->npages * PAGE_SIZE == mem->memory_size)
1101 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1102 mem->guest_phys_addr, mem->memory_size);
1104 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
1108 void kvm_arch_flush_shadow_all(struct kvm *kvm)
1112 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1113 struct kvm_memory_slot *slot)
1117 static int __init kvm_s390_init(void)
1120 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1125 * guests can ask for up to 255+1 double words, we need a full page
1126 * to hold the maximum amount of facilities. On the other hand, we
1127 * only set facilities that are known to work in KVM.
1129 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1134 memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
1135 facilities[0] &= 0xff82fff3f47c0000ULL;
1136 facilities[1] &= 0x001c000000000000ULL;
1140 static void __exit kvm_s390_exit(void)
1142 free_page((unsigned long) facilities);
1146 module_init(kvm_s390_init);
1147 module_exit(kvm_s390_exit);
1150 * Enable autoloading of the kvm module.
1151 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
1152 * since x86 takes a different approach.
1154 #include <linux/miscdevice.h>
1155 MODULE_ALIAS_MISCDEV(KVM_MINOR);
1156 MODULE_ALIAS("devname:kvm");