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>
14 * Jason J. Herne <jjherne@us.ibm.com>
17 #include <linux/compiler.h>
18 #include <linux/err.h>
20 #include <linux/hrtimer.h>
21 #include <linux/init.h>
22 #include <linux/kvm.h>
23 #include <linux/kvm_host.h>
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/timer.h>
27 #include <asm/asm-offsets.h>
28 #include <asm/lowcore.h>
29 #include <asm/pgtable.h>
31 #include <asm/switch_to.h>
32 #include <asm/facility.h>
37 #define CREATE_TRACE_POINTS
39 #include "trace-s390.h"
41 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
43 struct kvm_stats_debugfs_item debugfs_entries[] = {
44 { "userspace_handled", VCPU_STAT(exit_userspace) },
45 { "exit_null", VCPU_STAT(exit_null) },
46 { "exit_validity", VCPU_STAT(exit_validity) },
47 { "exit_stop_request", VCPU_STAT(exit_stop_request) },
48 { "exit_external_request", VCPU_STAT(exit_external_request) },
49 { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
50 { "exit_instruction", VCPU_STAT(exit_instruction) },
51 { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
52 { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
53 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
54 { "instruction_lctl", VCPU_STAT(instruction_lctl) },
55 { "instruction_stctl", VCPU_STAT(instruction_stctl) },
56 { "instruction_stctg", VCPU_STAT(instruction_stctg) },
57 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
58 { "deliver_external_call", VCPU_STAT(deliver_external_call) },
59 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
60 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
61 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
62 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
63 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
64 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
65 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
66 { "instruction_pfmf", VCPU_STAT(instruction_pfmf) },
67 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
68 { "instruction_spx", VCPU_STAT(instruction_spx) },
69 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
70 { "instruction_stap", VCPU_STAT(instruction_stap) },
71 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
72 { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) },
73 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
74 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
75 { "instruction_essa", VCPU_STAT(instruction_essa) },
76 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
77 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
78 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
79 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
80 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
81 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
82 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
83 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
84 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
85 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
86 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
87 { "diagnose_10", VCPU_STAT(diagnose_10) },
88 { "diagnose_44", VCPU_STAT(diagnose_44) },
89 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
93 unsigned long *vfacilities;
94 static struct gmap_notifier gmap_notifier;
96 /* test availability of vfacility */
97 int test_vfacility(unsigned long nr)
99 return __test_facility(nr, (void *) vfacilities);
102 /* Section: not file related */
103 int kvm_arch_hardware_enable(void *garbage)
105 /* every s390 is virtualization enabled ;-) */
109 void kvm_arch_hardware_disable(void *garbage)
113 static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
115 int kvm_arch_hardware_setup(void)
117 gmap_notifier.notifier_call = kvm_gmap_notifier;
118 gmap_register_ipte_notifier(&gmap_notifier);
122 void kvm_arch_hardware_unsetup(void)
124 gmap_unregister_ipte_notifier(&gmap_notifier);
127 void kvm_arch_check_processor_compat(void *rtn)
131 int kvm_arch_init(void *opaque)
136 void kvm_arch_exit(void)
140 /* Section: device related */
141 long kvm_arch_dev_ioctl(struct file *filp,
142 unsigned int ioctl, unsigned long arg)
144 if (ioctl == KVM_S390_ENABLE_SIE)
145 return s390_enable_sie();
149 int kvm_dev_ioctl_check_extension(long ext)
154 case KVM_CAP_S390_PSW:
155 case KVM_CAP_S390_GMAP:
156 case KVM_CAP_SYNC_MMU:
157 #ifdef CONFIG_KVM_S390_UCONTROL
158 case KVM_CAP_S390_UCONTROL:
160 case KVM_CAP_ASYNC_PF:
161 case KVM_CAP_SYNC_REGS:
162 case KVM_CAP_ONE_REG:
163 case KVM_CAP_ENABLE_CAP:
164 case KVM_CAP_S390_CSS_SUPPORT:
165 case KVM_CAP_IOEVENTFD:
166 case KVM_CAP_DEVICE_CTRL:
167 case KVM_CAP_ENABLE_CAP_VM:
168 case KVM_CAP_VM_ATTRIBUTES:
171 case KVM_CAP_NR_VCPUS:
172 case KVM_CAP_MAX_VCPUS:
175 case KVM_CAP_NR_MEMSLOTS:
176 r = KVM_USER_MEM_SLOTS;
178 case KVM_CAP_S390_COW:
179 r = MACHINE_HAS_ESOP;
187 static void kvm_s390_sync_dirty_log(struct kvm *kvm,
188 struct kvm_memory_slot *memslot)
190 gfn_t cur_gfn, last_gfn;
191 unsigned long address;
192 struct gmap *gmap = kvm->arch.gmap;
194 down_read(&gmap->mm->mmap_sem);
195 /* Loop over all guest pages */
196 last_gfn = memslot->base_gfn + memslot->npages;
197 for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) {
198 address = gfn_to_hva_memslot(memslot, cur_gfn);
200 if (gmap_test_and_clear_dirty(address, gmap))
201 mark_page_dirty(kvm, cur_gfn);
203 up_read(&gmap->mm->mmap_sem);
206 /* Section: vm related */
208 * Get (and clear) the dirty memory log for a memory slot.
210 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
211 struct kvm_dirty_log *log)
215 struct kvm_memory_slot *memslot;
218 mutex_lock(&kvm->slots_lock);
221 if (log->slot >= KVM_USER_MEM_SLOTS)
224 memslot = id_to_memslot(kvm->memslots, log->slot);
226 if (!memslot->dirty_bitmap)
229 kvm_s390_sync_dirty_log(kvm, memslot);
230 r = kvm_get_dirty_log(kvm, log, &is_dirty);
234 /* Clear the dirty log */
236 n = kvm_dirty_bitmap_bytes(memslot);
237 memset(memslot->dirty_bitmap, 0, n);
241 mutex_unlock(&kvm->slots_lock);
245 static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
253 case KVM_CAP_S390_IRQCHIP:
254 kvm->arch.use_irqchip = 1;
264 static int kvm_s390_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
268 switch (attr->attr) {
269 case KVM_S390_VM_MEM_ENABLE_CMMA:
271 mutex_lock(&kvm->lock);
272 if (atomic_read(&kvm->online_vcpus) == 0) {
273 kvm->arch.use_cmma = 1;
276 mutex_unlock(&kvm->lock);
278 case KVM_S390_VM_MEM_CLR_CMMA:
279 mutex_lock(&kvm->lock);
280 idx = srcu_read_lock(&kvm->srcu);
281 page_table_reset_pgste(kvm->arch.gmap->mm, 0, TASK_SIZE, false);
282 srcu_read_unlock(&kvm->srcu, idx);
283 mutex_unlock(&kvm->lock);
293 static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr)
297 switch (attr->group) {
298 case KVM_S390_VM_MEM_CTRL:
299 ret = kvm_s390_mem_control(kvm, attr);
309 static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr)
314 static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr)
318 switch (attr->group) {
319 case KVM_S390_VM_MEM_CTRL:
320 switch (attr->attr) {
321 case KVM_S390_VM_MEM_ENABLE_CMMA:
322 case KVM_S390_VM_MEM_CLR_CMMA:
338 long kvm_arch_vm_ioctl(struct file *filp,
339 unsigned int ioctl, unsigned long arg)
341 struct kvm *kvm = filp->private_data;
342 void __user *argp = (void __user *)arg;
343 struct kvm_device_attr attr;
347 case KVM_S390_INTERRUPT: {
348 struct kvm_s390_interrupt s390int;
351 if (copy_from_user(&s390int, argp, sizeof(s390int)))
353 r = kvm_s390_inject_vm(kvm, &s390int);
356 case KVM_ENABLE_CAP: {
357 struct kvm_enable_cap cap;
359 if (copy_from_user(&cap, argp, sizeof(cap)))
361 r = kvm_vm_ioctl_enable_cap(kvm, &cap);
364 case KVM_CREATE_IRQCHIP: {
365 struct kvm_irq_routing_entry routing;
368 if (kvm->arch.use_irqchip) {
369 /* Set up dummy routing. */
370 memset(&routing, 0, sizeof(routing));
371 kvm_set_irq_routing(kvm, &routing, 0, 0);
376 case KVM_SET_DEVICE_ATTR: {
378 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
380 r = kvm_s390_vm_set_attr(kvm, &attr);
383 case KVM_GET_DEVICE_ATTR: {
385 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
387 r = kvm_s390_vm_get_attr(kvm, &attr);
390 case KVM_HAS_DEVICE_ATTR: {
392 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
394 r = kvm_s390_vm_has_attr(kvm, &attr);
404 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
408 static unsigned long sca_offset;
411 #ifdef CONFIG_KVM_S390_UCONTROL
412 if (type & ~KVM_VM_S390_UCONTROL)
414 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
421 rc = s390_enable_sie();
427 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
430 spin_lock(&kvm_lock);
431 sca_offset = (sca_offset + 16) & 0x7f0;
432 kvm->arch.sca = (struct sca_block *) ((char *) kvm->arch.sca + sca_offset);
433 spin_unlock(&kvm_lock);
435 sprintf(debug_name, "kvm-%u", current->pid);
437 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
441 spin_lock_init(&kvm->arch.float_int.lock);
442 INIT_LIST_HEAD(&kvm->arch.float_int.list);
443 init_waitqueue_head(&kvm->arch.ipte_wq);
445 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
446 VM_EVENT(kvm, 3, "%s", "vm created");
448 if (type & KVM_VM_S390_UCONTROL) {
449 kvm->arch.gmap = NULL;
451 kvm->arch.gmap = gmap_alloc(current->mm);
454 kvm->arch.gmap->private = kvm;
455 kvm->arch.gmap->pfault_enabled = 0;
458 kvm->arch.css_support = 0;
459 kvm->arch.use_irqchip = 0;
461 spin_lock_init(&kvm->arch.start_stop_lock);
465 debug_unregister(kvm->arch.dbf);
467 free_page((unsigned long)(kvm->arch.sca));
472 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
474 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
475 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
476 kvm_s390_clear_local_irqs(vcpu);
477 kvm_clear_async_pf_completion_queue(vcpu);
478 if (!kvm_is_ucontrol(vcpu->kvm)) {
479 clear_bit(63 - vcpu->vcpu_id,
480 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
481 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
482 (__u64) vcpu->arch.sie_block)
483 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
487 if (kvm_is_ucontrol(vcpu->kvm))
488 gmap_free(vcpu->arch.gmap);
490 if (kvm_s390_cmma_enabled(vcpu->kvm))
491 kvm_s390_vcpu_unsetup_cmma(vcpu);
492 free_page((unsigned long)(vcpu->arch.sie_block));
494 kvm_vcpu_uninit(vcpu);
495 kmem_cache_free(kvm_vcpu_cache, vcpu);
498 static void kvm_free_vcpus(struct kvm *kvm)
501 struct kvm_vcpu *vcpu;
503 kvm_for_each_vcpu(i, vcpu, kvm)
504 kvm_arch_vcpu_destroy(vcpu);
506 mutex_lock(&kvm->lock);
507 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
508 kvm->vcpus[i] = NULL;
510 atomic_set(&kvm->online_vcpus, 0);
511 mutex_unlock(&kvm->lock);
514 void kvm_arch_sync_events(struct kvm *kvm)
518 void kvm_arch_destroy_vm(struct kvm *kvm)
521 free_page((unsigned long)(kvm->arch.sca));
522 debug_unregister(kvm->arch.dbf);
523 if (!kvm_is_ucontrol(kvm))
524 gmap_free(kvm->arch.gmap);
525 kvm_s390_destroy_adapters(kvm);
526 kvm_s390_clear_float_irqs(kvm);
529 /* Section: vcpu related */
530 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
532 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
533 kvm_clear_async_pf_completion_queue(vcpu);
534 if (kvm_is_ucontrol(vcpu->kvm)) {
535 vcpu->arch.gmap = gmap_alloc(current->mm);
536 if (!vcpu->arch.gmap)
538 vcpu->arch.gmap->private = vcpu->kvm;
542 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
543 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
550 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
555 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
557 save_fp_ctl(&vcpu->arch.host_fpregs.fpc);
558 save_fp_regs(vcpu->arch.host_fpregs.fprs);
559 save_access_regs(vcpu->arch.host_acrs);
560 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
561 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
562 restore_access_regs(vcpu->run->s.regs.acrs);
563 gmap_enable(vcpu->arch.gmap);
564 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
567 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
569 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
570 gmap_disable(vcpu->arch.gmap);
571 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
572 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
573 save_access_regs(vcpu->run->s.regs.acrs);
574 restore_fp_ctl(&vcpu->arch.host_fpregs.fpc);
575 restore_fp_regs(vcpu->arch.host_fpregs.fprs);
576 restore_access_regs(vcpu->arch.host_acrs);
579 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
581 /* this equals initial cpu reset in pop, but we don't switch to ESA */
582 vcpu->arch.sie_block->gpsw.mask = 0UL;
583 vcpu->arch.sie_block->gpsw.addr = 0UL;
584 kvm_s390_set_prefix(vcpu, 0);
585 vcpu->arch.sie_block->cputm = 0UL;
586 vcpu->arch.sie_block->ckc = 0UL;
587 vcpu->arch.sie_block->todpr = 0;
588 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
589 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
590 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
591 vcpu->arch.guest_fpregs.fpc = 0;
592 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
593 vcpu->arch.sie_block->gbea = 1;
594 vcpu->arch.sie_block->pp = 0;
595 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
596 kvm_clear_async_pf_completion_queue(vcpu);
597 kvm_s390_vcpu_stop(vcpu);
598 kvm_s390_clear_local_irqs(vcpu);
601 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
606 void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu)
608 free_page(vcpu->arch.sie_block->cbrlo);
609 vcpu->arch.sie_block->cbrlo = 0;
612 int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu)
614 vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL);
615 if (!vcpu->arch.sie_block->cbrlo)
618 vcpu->arch.sie_block->ecb2 |= 0x80;
619 vcpu->arch.sie_block->ecb2 &= ~0x08;
623 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
627 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
631 vcpu->arch.sie_block->ecb = 6;
632 if (test_vfacility(50) && test_vfacility(73))
633 vcpu->arch.sie_block->ecb |= 0x10;
635 vcpu->arch.sie_block->ecb2 = 8;
636 vcpu->arch.sie_block->eca = 0xC1002000U;
638 vcpu->arch.sie_block->eca |= 1;
639 vcpu->arch.sie_block->fac = (int) (long) vfacilities;
640 vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE;
641 if (kvm_s390_cmma_enabled(vcpu->kvm)) {
642 rc = kvm_s390_vcpu_setup_cmma(vcpu);
646 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
647 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
648 (unsigned long) vcpu);
649 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
650 get_cpu_id(&vcpu->arch.cpu_id);
651 vcpu->arch.cpu_id.version = 0xff;
655 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
658 struct kvm_vcpu *vcpu;
659 struct sie_page *sie_page;
662 if (id >= KVM_MAX_VCPUS)
667 vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
671 sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
675 vcpu->arch.sie_block = &sie_page->sie_block;
676 vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;
678 vcpu->arch.sie_block->icpua = id;
679 if (!kvm_is_ucontrol(kvm)) {
680 if (!kvm->arch.sca) {
684 if (!kvm->arch.sca->cpu[id].sda)
685 kvm->arch.sca->cpu[id].sda =
686 (__u64) vcpu->arch.sie_block;
687 vcpu->arch.sie_block->scaoh =
688 (__u32)(((__u64)kvm->arch.sca) >> 32);
689 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
690 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
693 spin_lock_init(&vcpu->arch.local_int.lock);
694 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
695 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
696 vcpu->arch.local_int.wq = &vcpu->wq;
697 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
699 rc = kvm_vcpu_init(vcpu, kvm, id);
701 goto out_free_sie_block;
702 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
703 vcpu->arch.sie_block);
704 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
708 free_page((unsigned long)(vcpu->arch.sie_block));
710 kmem_cache_free(kvm_vcpu_cache, vcpu);
715 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
717 return kvm_cpu_has_interrupt(vcpu);
720 void s390_vcpu_block(struct kvm_vcpu *vcpu)
722 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
725 void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
727 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
731 * Kick a guest cpu out of SIE and wait until SIE is not running.
732 * If the CPU is not running (e.g. waiting as idle) the function will
733 * return immediately. */
734 void exit_sie(struct kvm_vcpu *vcpu)
736 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
737 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
741 /* Kick a guest cpu out of SIE and prevent SIE-reentry */
742 void exit_sie_sync(struct kvm_vcpu *vcpu)
744 s390_vcpu_block(vcpu);
748 static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
751 struct kvm *kvm = gmap->private;
752 struct kvm_vcpu *vcpu;
754 kvm_for_each_vcpu(i, vcpu, kvm) {
755 /* match against both prefix pages */
756 if (vcpu->arch.sie_block->prefix == (address & ~0x1000UL)) {
757 VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
758 kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
764 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
766 /* kvm common code refers to this, but never calls it */
771 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
772 struct kvm_one_reg *reg)
777 case KVM_REG_S390_TODPR:
778 r = put_user(vcpu->arch.sie_block->todpr,
779 (u32 __user *)reg->addr);
781 case KVM_REG_S390_EPOCHDIFF:
782 r = put_user(vcpu->arch.sie_block->epoch,
783 (u64 __user *)reg->addr);
785 case KVM_REG_S390_CPU_TIMER:
786 r = put_user(vcpu->arch.sie_block->cputm,
787 (u64 __user *)reg->addr);
789 case KVM_REG_S390_CLOCK_COMP:
790 r = put_user(vcpu->arch.sie_block->ckc,
791 (u64 __user *)reg->addr);
793 case KVM_REG_S390_PFTOKEN:
794 r = put_user(vcpu->arch.pfault_token,
795 (u64 __user *)reg->addr);
797 case KVM_REG_S390_PFCOMPARE:
798 r = put_user(vcpu->arch.pfault_compare,
799 (u64 __user *)reg->addr);
801 case KVM_REG_S390_PFSELECT:
802 r = put_user(vcpu->arch.pfault_select,
803 (u64 __user *)reg->addr);
805 case KVM_REG_S390_PP:
806 r = put_user(vcpu->arch.sie_block->pp,
807 (u64 __user *)reg->addr);
809 case KVM_REG_S390_GBEA:
810 r = put_user(vcpu->arch.sie_block->gbea,
811 (u64 __user *)reg->addr);
820 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
821 struct kvm_one_reg *reg)
826 case KVM_REG_S390_TODPR:
827 r = get_user(vcpu->arch.sie_block->todpr,
828 (u32 __user *)reg->addr);
830 case KVM_REG_S390_EPOCHDIFF:
831 r = get_user(vcpu->arch.sie_block->epoch,
832 (u64 __user *)reg->addr);
834 case KVM_REG_S390_CPU_TIMER:
835 r = get_user(vcpu->arch.sie_block->cputm,
836 (u64 __user *)reg->addr);
838 case KVM_REG_S390_CLOCK_COMP:
839 r = get_user(vcpu->arch.sie_block->ckc,
840 (u64 __user *)reg->addr);
842 case KVM_REG_S390_PFTOKEN:
843 r = get_user(vcpu->arch.pfault_token,
844 (u64 __user *)reg->addr);
846 case KVM_REG_S390_PFCOMPARE:
847 r = get_user(vcpu->arch.pfault_compare,
848 (u64 __user *)reg->addr);
850 case KVM_REG_S390_PFSELECT:
851 r = get_user(vcpu->arch.pfault_select,
852 (u64 __user *)reg->addr);
854 case KVM_REG_S390_PP:
855 r = get_user(vcpu->arch.sie_block->pp,
856 (u64 __user *)reg->addr);
858 case KVM_REG_S390_GBEA:
859 r = get_user(vcpu->arch.sie_block->gbea,
860 (u64 __user *)reg->addr);
869 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
871 kvm_s390_vcpu_initial_reset(vcpu);
875 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
877 memcpy(&vcpu->run->s.regs.gprs, ®s->gprs, sizeof(regs->gprs));
881 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
883 memcpy(®s->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
887 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
888 struct kvm_sregs *sregs)
890 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
891 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
892 restore_access_regs(vcpu->run->s.regs.acrs);
896 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
897 struct kvm_sregs *sregs)
899 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
900 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
904 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
906 if (test_fp_ctl(fpu->fpc))
908 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
909 vcpu->arch.guest_fpregs.fpc = fpu->fpc;
910 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
911 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
915 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
917 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
918 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
922 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
926 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
929 vcpu->run->psw_mask = psw.mask;
930 vcpu->run->psw_addr = psw.addr;
935 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
936 struct kvm_translation *tr)
938 return -EINVAL; /* not implemented yet */
941 #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \
942 KVM_GUESTDBG_USE_HW_BP | \
945 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
946 struct kvm_guest_debug *dbg)
950 vcpu->guest_debug = 0;
951 kvm_s390_clear_bp_data(vcpu);
953 if (vcpu->guest_debug & ~VALID_GUESTDBG_FLAGS)
956 if (dbg->control & KVM_GUESTDBG_ENABLE) {
957 vcpu->guest_debug = dbg->control;
958 /* enforce guest PER */
959 atomic_set_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
961 if (dbg->control & KVM_GUESTDBG_USE_HW_BP)
962 rc = kvm_s390_import_bp_data(vcpu, dbg);
964 atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
965 vcpu->arch.guestdbg.last_bp = 0;
969 vcpu->guest_debug = 0;
970 kvm_s390_clear_bp_data(vcpu);
971 atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
977 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
978 struct kvm_mp_state *mp_state)
980 return -EINVAL; /* not implemented yet */
983 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
984 struct kvm_mp_state *mp_state)
986 return -EINVAL; /* not implemented yet */
989 bool kvm_s390_cmma_enabled(struct kvm *kvm)
991 if (!MACHINE_IS_LPAR)
993 /* only enable for z10 and later */
994 if (!MACHINE_HAS_EDAT1)
996 if (!kvm->arch.use_cmma)
1001 static bool ibs_enabled(struct kvm_vcpu *vcpu)
1003 return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS;
1006 static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
1009 s390_vcpu_unblock(vcpu);
1011 * We use MMU_RELOAD just to re-arm the ipte notifier for the
1012 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
1013 * This ensures that the ipte instruction for this request has
1014 * already finished. We might race against a second unmapper that
1015 * wants to set the blocking bit. Lets just retry the request loop.
1017 if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
1019 rc = gmap_ipte_notify(vcpu->arch.gmap,
1020 vcpu->arch.sie_block->prefix,
1027 if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) {
1028 if (!ibs_enabled(vcpu)) {
1029 trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1);
1030 atomic_set_mask(CPUSTAT_IBS,
1031 &vcpu->arch.sie_block->cpuflags);
1036 if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) {
1037 if (ibs_enabled(vcpu)) {
1038 trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0);
1039 atomic_clear_mask(CPUSTAT_IBS,
1040 &vcpu->arch.sie_block->cpuflags);
1049 * kvm_arch_fault_in_page - fault-in guest page if necessary
1050 * @vcpu: The corresponding virtual cpu
1051 * @gpa: Guest physical address
1052 * @writable: Whether the page should be writable or not
1054 * Make sure that a guest page has been faulted-in on the host.
1056 * Return: Zero on success, negative error code otherwise.
1058 long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable)
1060 struct mm_struct *mm = current->mm;
1064 hva = gmap_fault(gpa, vcpu->arch.gmap);
1065 if (IS_ERR_VALUE(hva))
1067 down_read(&mm->mmap_sem);
1068 rc = get_user_pages(current, mm, hva, 1, writable, 0, NULL, NULL);
1069 up_read(&mm->mmap_sem);
1071 return rc < 0 ? rc : 0;
1074 static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
1075 unsigned long token)
1077 struct kvm_s390_interrupt inti;
1078 inti.parm64 = token;
1081 inti.type = KVM_S390_INT_PFAULT_INIT;
1082 WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &inti));
1084 inti.type = KVM_S390_INT_PFAULT_DONE;
1085 WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
1089 void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
1090 struct kvm_async_pf *work)
1092 trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
1093 __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
1096 void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
1097 struct kvm_async_pf *work)
1099 trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
1100 __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
1103 void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
1104 struct kvm_async_pf *work)
1106 /* s390 will always inject the page directly */
1109 bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
1112 * s390 will always inject the page directly,
1113 * but we still want check_async_completion to cleanup
1118 static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
1121 struct kvm_arch_async_pf arch;
1124 if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
1126 if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
1127 vcpu->arch.pfault_compare)
1129 if (psw_extint_disabled(vcpu))
1131 if (kvm_cpu_has_interrupt(vcpu))
1133 if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul))
1135 if (!vcpu->arch.gmap->pfault_enabled)
1138 hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr));
1139 hva += current->thread.gmap_addr & ~PAGE_MASK;
1140 if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8))
1143 rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
1147 static int vcpu_pre_run(struct kvm_vcpu *vcpu)
1152 * On s390 notifications for arriving pages will be delivered directly
1153 * to the guest but the house keeping for completed pfaults is
1154 * handled outside the worker.
1156 kvm_check_async_pf_completion(vcpu);
1158 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
1163 if (test_thread_flag(TIF_MCCK_PENDING))
1166 if (!kvm_is_ucontrol(vcpu->kvm))
1167 kvm_s390_deliver_pending_interrupts(vcpu);
1169 rc = kvm_s390_handle_requests(vcpu);
1173 if (guestdbg_enabled(vcpu)) {
1174 kvm_s390_backup_guest_per_regs(vcpu);
1175 kvm_s390_patch_guest_per_regs(vcpu);
1178 vcpu->arch.sie_block->icptcode = 0;
1179 cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
1180 VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
1181 trace_kvm_s390_sie_enter(vcpu, cpuflags);
1186 static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
1190 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
1191 vcpu->arch.sie_block->icptcode);
1192 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
1194 if (guestdbg_enabled(vcpu))
1195 kvm_s390_restore_guest_per_regs(vcpu);
1197 if (exit_reason >= 0) {
1199 } else if (kvm_is_ucontrol(vcpu->kvm)) {
1200 vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
1201 vcpu->run->s390_ucontrol.trans_exc_code =
1202 current->thread.gmap_addr;
1203 vcpu->run->s390_ucontrol.pgm_code = 0x10;
1206 } else if (current->thread.gmap_pfault) {
1207 trace_kvm_s390_major_guest_pfault(vcpu);
1208 current->thread.gmap_pfault = 0;
1209 if (kvm_arch_setup_async_pf(vcpu)) {
1212 gpa_t gpa = current->thread.gmap_addr;
1213 rc = kvm_arch_fault_in_page(vcpu, gpa, 1);
1218 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
1219 trace_kvm_s390_sie_fault(vcpu);
1220 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
1223 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
1226 if (kvm_is_ucontrol(vcpu->kvm))
1227 /* Don't exit for host interrupts. */
1228 rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0;
1230 rc = kvm_handle_sie_intercept(vcpu);
1236 static int __vcpu_run(struct kvm_vcpu *vcpu)
1238 int rc, exit_reason;
1241 * We try to hold kvm->srcu during most of vcpu_run (except when run-
1242 * ning the guest), so that memslots (and other stuff) are protected
1244 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
1247 rc = vcpu_pre_run(vcpu);
1251 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
1253 * As PF_VCPU will be used in fault handler, between
1254 * guest_enter and guest_exit should be no uaccess.
1259 exit_reason = sie64a(vcpu->arch.sie_block,
1260 vcpu->run->s.regs.gprs);
1262 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
1264 rc = vcpu_post_run(vcpu, exit_reason);
1265 } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc);
1267 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
1271 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1276 if (guestdbg_exit_pending(vcpu)) {
1277 kvm_s390_prepare_debug_exit(vcpu);
1281 if (vcpu->sigset_active)
1282 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
1284 kvm_s390_vcpu_start(vcpu);
1286 switch (kvm_run->exit_reason) {
1287 case KVM_EXIT_S390_SIEIC:
1288 case KVM_EXIT_UNKNOWN:
1290 case KVM_EXIT_S390_RESET:
1291 case KVM_EXIT_S390_UCONTROL:
1292 case KVM_EXIT_S390_TSCH:
1293 case KVM_EXIT_DEBUG:
1299 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
1300 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
1301 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
1302 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
1303 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1305 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
1306 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
1307 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
1308 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1312 rc = __vcpu_run(vcpu);
1314 if (signal_pending(current) && !rc) {
1315 kvm_run->exit_reason = KVM_EXIT_INTR;
1319 if (guestdbg_exit_pending(vcpu) && !rc) {
1320 kvm_s390_prepare_debug_exit(vcpu);
1324 if (rc == -EOPNOTSUPP) {
1325 /* intercept cannot be handled in-kernel, prepare kvm-run */
1326 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
1327 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
1328 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
1329 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
1333 if (rc == -EREMOTE) {
1334 /* intercept was handled, but userspace support is needed
1335 * kvm_run has been prepared by the handler */
1339 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
1340 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
1341 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
1342 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
1344 if (vcpu->sigset_active)
1345 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1347 vcpu->stat.exit_userspace++;
1352 * store status at address
1353 * we use have two special cases:
1354 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
1355 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
1357 int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa)
1359 unsigned char archmode = 1;
1363 if (gpa == KVM_S390_STORE_STATUS_NOADDR) {
1364 if (write_guest_abs(vcpu, 163, &archmode, 1))
1366 gpa = SAVE_AREA_BASE;
1367 } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) {
1368 if (write_guest_real(vcpu, 163, &archmode, 1))
1370 gpa = kvm_s390_real_to_abs(vcpu, SAVE_AREA_BASE);
1372 rc = write_guest_abs(vcpu, gpa + offsetof(struct save_area, fp_regs),
1373 vcpu->arch.guest_fpregs.fprs, 128);
1374 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, gp_regs),
1375 vcpu->run->s.regs.gprs, 128);
1376 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, psw),
1377 &vcpu->arch.sie_block->gpsw, 16);
1378 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, pref_reg),
1379 &vcpu->arch.sie_block->prefix, 4);
1380 rc |= write_guest_abs(vcpu,
1381 gpa + offsetof(struct save_area, fp_ctrl_reg),
1382 &vcpu->arch.guest_fpregs.fpc, 4);
1383 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, tod_reg),
1384 &vcpu->arch.sie_block->todpr, 4);
1385 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, timer),
1386 &vcpu->arch.sie_block->cputm, 8);
1387 clkcomp = vcpu->arch.sie_block->ckc >> 8;
1388 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, clk_cmp),
1390 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, acc_regs),
1391 &vcpu->run->s.regs.acrs, 64);
1392 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, ctrl_regs),
1393 &vcpu->arch.sie_block->gcr, 128);
1394 return rc ? -EFAULT : 0;
1397 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
1400 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
1401 * copying in vcpu load/put. Lets update our copies before we save
1402 * it into the save area
1404 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1405 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
1406 save_access_regs(vcpu->run->s.regs.acrs);
1408 return kvm_s390_store_status_unloaded(vcpu, addr);
1411 static inline int is_vcpu_stopped(struct kvm_vcpu *vcpu)
1413 return atomic_read(&(vcpu)->arch.sie_block->cpuflags) & CPUSTAT_STOPPED;
1416 static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
1418 kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu);
1419 kvm_make_request(KVM_REQ_DISABLE_IBS, vcpu);
1420 exit_sie_sync(vcpu);
1423 static void __disable_ibs_on_all_vcpus(struct kvm *kvm)
1426 struct kvm_vcpu *vcpu;
1428 kvm_for_each_vcpu(i, vcpu, kvm) {
1429 __disable_ibs_on_vcpu(vcpu);
1433 static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
1435 kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu);
1436 kvm_make_request(KVM_REQ_ENABLE_IBS, vcpu);
1437 exit_sie_sync(vcpu);
1440 void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu)
1442 int i, online_vcpus, started_vcpus = 0;
1444 if (!is_vcpu_stopped(vcpu))
1447 trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1);
1448 /* Only one cpu at a time may enter/leave the STOPPED state. */
1449 spin_lock_bh(&vcpu->kvm->arch.start_stop_lock);
1450 online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
1452 for (i = 0; i < online_vcpus; i++) {
1453 if (!is_vcpu_stopped(vcpu->kvm->vcpus[i]))
1457 if (started_vcpus == 0) {
1458 /* we're the only active VCPU -> speed it up */
1459 __enable_ibs_on_vcpu(vcpu);
1460 } else if (started_vcpus == 1) {
1462 * As we are starting a second VCPU, we have to disable
1463 * the IBS facility on all VCPUs to remove potentially
1464 * oustanding ENABLE requests.
1466 __disable_ibs_on_all_vcpus(vcpu->kvm);
1469 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
1471 * Another VCPU might have used IBS while we were offline.
1472 * Let's play safe and flush the VCPU at startup.
1474 vcpu->arch.sie_block->ihcpu = 0xffff;
1475 spin_unlock_bh(&vcpu->kvm->arch.start_stop_lock);
1479 void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu)
1481 int i, online_vcpus, started_vcpus = 0;
1482 struct kvm_vcpu *started_vcpu = NULL;
1484 if (is_vcpu_stopped(vcpu))
1487 trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0);
1488 /* Only one cpu at a time may enter/leave the STOPPED state. */
1489 spin_lock_bh(&vcpu->kvm->arch.start_stop_lock);
1490 online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
1492 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
1493 __disable_ibs_on_vcpu(vcpu);
1495 for (i = 0; i < online_vcpus; i++) {
1496 if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) {
1498 started_vcpu = vcpu->kvm->vcpus[i];
1502 if (started_vcpus == 1) {
1504 * As we only have one VCPU left, we want to enable the
1505 * IBS facility for that VCPU to speed it up.
1507 __enable_ibs_on_vcpu(started_vcpu);
1510 spin_unlock_bh(&vcpu->kvm->arch.start_stop_lock);
1514 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
1515 struct kvm_enable_cap *cap)
1523 case KVM_CAP_S390_CSS_SUPPORT:
1524 if (!vcpu->kvm->arch.css_support) {
1525 vcpu->kvm->arch.css_support = 1;
1526 trace_kvm_s390_enable_css(vcpu->kvm);
1537 long kvm_arch_vcpu_ioctl(struct file *filp,
1538 unsigned int ioctl, unsigned long arg)
1540 struct kvm_vcpu *vcpu = filp->private_data;
1541 void __user *argp = (void __user *)arg;
1546 case KVM_S390_INTERRUPT: {
1547 struct kvm_s390_interrupt s390int;
1550 if (copy_from_user(&s390int, argp, sizeof(s390int)))
1552 r = kvm_s390_inject_vcpu(vcpu, &s390int);
1555 case KVM_S390_STORE_STATUS:
1556 idx = srcu_read_lock(&vcpu->kvm->srcu);
1557 r = kvm_s390_vcpu_store_status(vcpu, arg);
1558 srcu_read_unlock(&vcpu->kvm->srcu, idx);
1560 case KVM_S390_SET_INITIAL_PSW: {
1564 if (copy_from_user(&psw, argp, sizeof(psw)))
1566 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
1569 case KVM_S390_INITIAL_RESET:
1570 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
1572 case KVM_SET_ONE_REG:
1573 case KVM_GET_ONE_REG: {
1574 struct kvm_one_reg reg;
1576 if (copy_from_user(®, argp, sizeof(reg)))
1578 if (ioctl == KVM_SET_ONE_REG)
1579 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, ®);
1581 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, ®);
1584 #ifdef CONFIG_KVM_S390_UCONTROL
1585 case KVM_S390_UCAS_MAP: {
1586 struct kvm_s390_ucas_mapping ucasmap;
1588 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1593 if (!kvm_is_ucontrol(vcpu->kvm)) {
1598 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
1599 ucasmap.vcpu_addr, ucasmap.length);
1602 case KVM_S390_UCAS_UNMAP: {
1603 struct kvm_s390_ucas_mapping ucasmap;
1605 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1610 if (!kvm_is_ucontrol(vcpu->kvm)) {
1615 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
1620 case KVM_S390_VCPU_FAULT: {
1621 r = gmap_fault(arg, vcpu->arch.gmap);
1622 if (!IS_ERR_VALUE(r))
1626 case KVM_ENABLE_CAP:
1628 struct kvm_enable_cap cap;
1630 if (copy_from_user(&cap, argp, sizeof(cap)))
1632 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1641 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1643 #ifdef CONFIG_KVM_S390_UCONTROL
1644 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
1645 && (kvm_is_ucontrol(vcpu->kvm))) {
1646 vmf->page = virt_to_page(vcpu->arch.sie_block);
1647 get_page(vmf->page);
1651 return VM_FAULT_SIGBUS;
1654 void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
1655 struct kvm_memory_slot *dont)
1659 int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
1660 unsigned long npages)
1665 void kvm_arch_memslots_updated(struct kvm *kvm)
1669 /* Section: memory related */
1670 int kvm_arch_prepare_memory_region(struct kvm *kvm,
1671 struct kvm_memory_slot *memslot,
1672 struct kvm_userspace_memory_region *mem,
1673 enum kvm_mr_change change)
1675 /* A few sanity checks. We can have memory slots which have to be
1676 located/ended at a segment boundary (1MB). The memory in userland is
1677 ok to be fragmented into various different vmas. It is okay to mmap()
1678 and munmap() stuff in this slot after doing this call at any time */
1680 if (mem->userspace_addr & 0xffffful)
1683 if (mem->memory_size & 0xffffful)
1689 void kvm_arch_commit_memory_region(struct kvm *kvm,
1690 struct kvm_userspace_memory_region *mem,
1691 const struct kvm_memory_slot *old,
1692 enum kvm_mr_change change)
1696 /* If the basics of the memslot do not change, we do not want
1697 * to update the gmap. Every update causes several unnecessary
1698 * segment translation exceptions. This is usually handled just
1699 * fine by the normal fault handler + gmap, but it will also
1700 * cause faults on the prefix page of running guest CPUs.
1702 if (old->userspace_addr == mem->userspace_addr &&
1703 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1704 old->npages * PAGE_SIZE == mem->memory_size)
1707 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1708 mem->guest_phys_addr, mem->memory_size);
1710 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
1714 void kvm_arch_flush_shadow_all(struct kvm *kvm)
1718 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1719 struct kvm_memory_slot *slot)
1723 static int __init kvm_s390_init(void)
1726 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1731 * guests can ask for up to 255+1 double words, we need a full page
1732 * to hold the maximum amount of facilities. On the other hand, we
1733 * only set facilities that are known to work in KVM.
1735 vfacilities = (unsigned long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1740 memcpy(vfacilities, S390_lowcore.stfle_fac_list, 16);
1741 vfacilities[0] &= 0xff82fff3f4fc2000UL;
1742 vfacilities[1] &= 0x005c000000000000UL;
1746 static void __exit kvm_s390_exit(void)
1748 free_page((unsigned long) vfacilities);
1752 module_init(kvm_s390_init);
1753 module_exit(kvm_s390_exit);
1756 * Enable autoloading of the kvm module.
1757 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
1758 * since x86 takes a different approach.
1760 #include <linux/miscdevice.h>
1761 MODULE_ALIAS_MISCDEV(KVM_MINOR);
1762 MODULE_ALIAS("devname:kvm");