]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame_incremental - arch/s390/kvm/kvm-s390.c
projects / mirror_ubuntu-jammy-kernel.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
KVM: s390: Avoid endless loops of specification exceptions
[mirror_ubuntu-jammy-kernel.git] / arch / s390 / kvm / kvm-s390.c
... / ...
CommitLineData
1/*
2 * hosting zSeries kernel virtual machines
3 *
4 * Copyright IBM Corp. 2008, 2009
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License (version 2 only)
8 * as published by the Free Software Foundation.
9 *
10 * Author(s): Carsten Otte <cotte@de.ibm.com>
11 * Christian Borntraeger <borntraeger@de.ibm.com>
12 * Heiko Carstens <heiko.carstens@de.ibm.com>
13 * Christian Ehrhardt <ehrhardt@de.ibm.com>
14 * Jason J. Herne <jjherne@us.ibm.com>
15 */
16
17#include <linux/compiler.h>
18#include <linux/err.h>
19#include <linux/fs.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>
30#include <asm/nmi.h>
31#include <asm/switch_to.h>
32#include <asm/facility.h>
33#include <asm/sclp.h>
34#include "kvm-s390.h"
35#include "gaccess.h"
36
37#define CREATE_TRACE_POINTS
38#include "trace.h"
39#include "trace-s390.h"
40
41#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
42
43struct 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) },
90 { NULL }
91};
92
93unsigned long *vfacilities;
94static struct gmap_notifier gmap_notifier;
95
96/* test availability of vfacility */
97int test_vfacility(unsigned long nr)
98{
99 return __test_facility(nr, (void *) vfacilities);
100}
101
102/* Section: not file related */
103int kvm_arch_hardware_enable(void *garbage)
104{
105 /* every s390 is virtualization enabled ;-) */
106 return 0;
107}
108
109void kvm_arch_hardware_disable(void *garbage)
110{
111}
112
113static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
114
115int kvm_arch_hardware_setup(void)
116{
117 gmap_notifier.notifier_call = kvm_gmap_notifier;
118 gmap_register_ipte_notifier(&gmap_notifier);
119 return 0;
120}
121
122void kvm_arch_hardware_unsetup(void)
123{
124 gmap_unregister_ipte_notifier(&gmap_notifier);
125}
126
127void kvm_arch_check_processor_compat(void *rtn)
128{
129}
130
131int kvm_arch_init(void *opaque)
132{
133 return 0;
134}
135
136void kvm_arch_exit(void)
137{
138}
139
140/* Section: device related */
141long kvm_arch_dev_ioctl(struct file *filp,
142 unsigned int ioctl, unsigned long arg)
143{
144 if (ioctl == KVM_S390_ENABLE_SIE)
145 return s390_enable_sie();
146 return -EINVAL;
147}
148
149int kvm_dev_ioctl_check_extension(long ext)
150{
151 int r;
152
153 switch (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:
159#endif
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:
169 r = 1;
170 break;
171 case KVM_CAP_NR_VCPUS:
172 case KVM_CAP_MAX_VCPUS:
173 r = KVM_MAX_VCPUS;
174 break;
175 case KVM_CAP_NR_MEMSLOTS:
176 r = KVM_USER_MEM_SLOTS;
177 break;
178 case KVM_CAP_S390_COW:
179 r = MACHINE_HAS_ESOP;
180 break;
181 default:
182 r = 0;
183 }
184 return r;
185}
186
187static void kvm_s390_sync_dirty_log(struct kvm *kvm,
188 struct kvm_memory_slot *memslot)
189{
190 gfn_t cur_gfn, last_gfn;
191 unsigned long address;
192 struct gmap *gmap = kvm->arch.gmap;
193
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);
199
200 if (gmap_test_and_clear_dirty(address, gmap))
201 mark_page_dirty(kvm, cur_gfn);
202 }
203 up_read(&gmap->mm->mmap_sem);
204}
205
206/* Section: vm related */
207/*
208 * Get (and clear) the dirty memory log for a memory slot.
209 */
210int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
211 struct kvm_dirty_log *log)
212{
213 int r;
214 unsigned long n;
215 struct kvm_memory_slot *memslot;
216 int is_dirty = 0;
217
218 mutex_lock(&kvm->slots_lock);
219
220 r = -EINVAL;
221 if (log->slot >= KVM_USER_MEM_SLOTS)
222 goto out;
223
224 memslot = id_to_memslot(kvm->memslots, log->slot);
225 r = -ENOENT;
226 if (!memslot->dirty_bitmap)
227 goto out;
228
229 kvm_s390_sync_dirty_log(kvm, memslot);
230 r = kvm_get_dirty_log(kvm, log, &is_dirty);
231 if (r)
232 goto out;
233
234 /* Clear the dirty log */
235 if (is_dirty) {
236 n = kvm_dirty_bitmap_bytes(memslot);
237 memset(memslot->dirty_bitmap, 0, n);
238 }
239 r = 0;
240out:
241 mutex_unlock(&kvm->slots_lock);
242 return r;
243}
244
245static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
246{
247 int r;
248
249 if (cap->flags)
250 return -EINVAL;
251
252 switch (cap->cap) {
253 case KVM_CAP_S390_IRQCHIP:
254 kvm->arch.use_irqchip = 1;
255 r = 0;
256 break;
257 default:
258 r = -EINVAL;
259 break;
260 }
261 return r;
262}
263
264static int kvm_s390_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
265{
266 int ret;
267 unsigned int idx;
268 switch (attr->attr) {
269 case KVM_S390_VM_MEM_ENABLE_CMMA:
270 ret = -EBUSY;
271 mutex_lock(&kvm->lock);
272 if (atomic_read(&kvm->online_vcpus) == 0) {
273 kvm->arch.use_cmma = 1;
274 ret = 0;
275 }
276 mutex_unlock(&kvm->lock);
277 break;
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);
284 ret = 0;
285 break;
286 default:
287 ret = -ENXIO;
288 break;
289 }
290 return ret;
291}
292
293static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr)
294{
295 int ret;
296
297 switch (attr->group) {
298 case KVM_S390_VM_MEM_CTRL:
299 ret = kvm_s390_mem_control(kvm, attr);
300 break;
301 default:
302 ret = -ENXIO;
303 break;
304 }
305
306 return ret;
307}
308
309static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr)
310{
311 return -ENXIO;
312}
313
314static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr)
315{
316 int ret;
317
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:
323 ret = 0;
324 break;
325 default:
326 ret = -ENXIO;
327 break;
328 }
329 break;
330 default:
331 ret = -ENXIO;
332 break;
333 }
334
335 return ret;
336}
337
338long kvm_arch_vm_ioctl(struct file *filp,
339 unsigned int ioctl, unsigned long arg)
340{
341 struct kvm *kvm = filp->private_data;
342 void __user *argp = (void __user *)arg;
343 struct kvm_device_attr attr;
344 int r;
345
346 switch (ioctl) {
347 case KVM_S390_INTERRUPT: {
348 struct kvm_s390_interrupt s390int;
349
350 r = -EFAULT;
351 if (copy_from_user(&s390int, argp, sizeof(s390int)))
352 break;
353 r = kvm_s390_inject_vm(kvm, &s390int);
354 break;
355 }
356 case KVM_ENABLE_CAP: {
357 struct kvm_enable_cap cap;
358 r = -EFAULT;
359 if (copy_from_user(&cap, argp, sizeof(cap)))
360 break;
361 r = kvm_vm_ioctl_enable_cap(kvm, &cap);
362 break;
363 }
364 case KVM_CREATE_IRQCHIP: {
365 struct kvm_irq_routing_entry routing;
366
367 r = -EINVAL;
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);
372 r = 0;
373 }
374 break;
375 }
376 case KVM_SET_DEVICE_ATTR: {
377 r = -EFAULT;
378 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
379 break;
380 r = kvm_s390_vm_set_attr(kvm, &attr);
381 break;
382 }
383 case KVM_GET_DEVICE_ATTR: {
384 r = -EFAULT;
385 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
386 break;
387 r = kvm_s390_vm_get_attr(kvm, &attr);
388 break;
389 }
390 case KVM_HAS_DEVICE_ATTR: {
391 r = -EFAULT;
392 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
393 break;
394 r = kvm_s390_vm_has_attr(kvm, &attr);
395 break;
396 }
397 default:
398 r = -ENOTTY;
399 }
400
401 return r;
402}
403
404int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
405{
406 int rc;
407 char debug_name[16];
408 static unsigned long sca_offset;
409
410 rc = -EINVAL;
411#ifdef CONFIG_KVM_S390_UCONTROL
412 if (type & ~KVM_VM_S390_UCONTROL)
413 goto out_err;
414 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
415 goto out_err;
416#else
417 if (type)
418 goto out_err;
419#endif
420
421 rc = s390_enable_sie();
422 if (rc)
423 goto out_err;
424
425 rc = -ENOMEM;
426
427 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
428 if (!kvm->arch.sca)
429 goto out_err;
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);
434
435 sprintf(debug_name, "kvm-%u", current->pid);
436
437 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
438 if (!kvm->arch.dbf)
439 goto out_nodbf;
440
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);
444
445 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
446 VM_EVENT(kvm, 3, "%s", "vm created");
447
448 if (type & KVM_VM_S390_UCONTROL) {
449 kvm->arch.gmap = NULL;
450 } else {
451 kvm->arch.gmap = gmap_alloc(current->mm);
452 if (!kvm->arch.gmap)
453 goto out_nogmap;
454 kvm->arch.gmap->private = kvm;
455 kvm->arch.gmap->pfault_enabled = 0;
456 }
457
458 kvm->arch.css_support = 0;
459 kvm->arch.use_irqchip = 0;
460
461 spin_lock_init(&kvm->arch.start_stop_lock);
462
463 return 0;
464out_nogmap:
465 debug_unregister(kvm->arch.dbf);
466out_nodbf:
467 free_page((unsigned long)(kvm->arch.sca));
468out_err:
469 return rc;
470}
471
472void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
473{
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;
484 }
485 smp_mb();
486
487 if (kvm_is_ucontrol(vcpu->kvm))
488 gmap_free(vcpu->arch.gmap);
489
490 if (kvm_s390_cmma_enabled(vcpu->kvm))
491 kvm_s390_vcpu_unsetup_cmma(vcpu);
492 free_page((unsigned long)(vcpu->arch.sie_block));
493
494 kvm_vcpu_uninit(vcpu);
495 kmem_cache_free(kvm_vcpu_cache, vcpu);
496}
497
498static void kvm_free_vcpus(struct kvm *kvm)
499{
500 unsigned int i;
501 struct kvm_vcpu *vcpu;
502
503 kvm_for_each_vcpu(i, vcpu, kvm)
504 kvm_arch_vcpu_destroy(vcpu);
505
506 mutex_lock(&kvm->lock);
507 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
508 kvm->vcpus[i] = NULL;
509
510 atomic_set(&kvm->online_vcpus, 0);
511 mutex_unlock(&kvm->lock);
512}
513
514void kvm_arch_sync_events(struct kvm *kvm)
515{
516}
517
518void kvm_arch_destroy_vm(struct kvm *kvm)
519{
520 kvm_free_vcpus(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);
527}
528
529/* Section: vcpu related */
530int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
531{
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)
537 return -ENOMEM;
538 vcpu->arch.gmap->private = vcpu->kvm;
539 return 0;
540 }
541
542 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
543 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
544 KVM_SYNC_GPRS |
545 KVM_SYNC_ACRS |
546 KVM_SYNC_CRS;
547 return 0;
548}
549
550void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
551{
552 /* Nothing todo */
553}
554
555void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
556{
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);
565}
566
567void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
568{
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);
577}
578
579static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
580{
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);
599}
600
601int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
602{
603 return 0;
604}
605
606void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu)
607{
608 free_page(vcpu->arch.sie_block->cbrlo);
609 vcpu->arch.sie_block->cbrlo = 0;
610}
611
612int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu)
613{
614 vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL);
615 if (!vcpu->arch.sie_block->cbrlo)
616 return -ENOMEM;
617
618 vcpu->arch.sie_block->ecb2 |= 0x80;
619 vcpu->arch.sie_block->ecb2 &= ~0x08;
620 return 0;
621}
622
623int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
624{
625 int rc = 0;
626
627 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
628 CPUSTAT_SM |
629 CPUSTAT_STOPPED |
630 CPUSTAT_GED);
631 vcpu->arch.sie_block->ecb = 6;
632 if (test_vfacility(50) && test_vfacility(73))
633 vcpu->arch.sie_block->ecb |= 0x10;
634
635 vcpu->arch.sie_block->ecb2 = 8;
636 vcpu->arch.sie_block->eca = 0xC1002000U;
637 if (sclp_has_siif())
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);
643 if (rc)
644 return rc;
645 }
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;
652 return rc;
653}
654
655struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
656 unsigned int id)
657{
658 struct kvm_vcpu *vcpu;
659 struct sie_page *sie_page;
660 int rc = -EINVAL;
661
662 if (id >= KVM_MAX_VCPUS)
663 goto out;
664
665 rc = -ENOMEM;
666
667 vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
668 if (!vcpu)
669 goto out;
670
671 sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
672 if (!sie_page)
673 goto out_free_cpu;
674
675 vcpu->arch.sie_block = &sie_page->sie_block;
676 vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;
677
678 vcpu->arch.sie_block->icpua = id;
679 if (!kvm_is_ucontrol(kvm)) {
680 if (!kvm->arch.sca) {
681 WARN_ON_ONCE(1);
682 goto out_free_cpu;
683 }
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);
691 }
692
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;
698
699 rc = kvm_vcpu_init(vcpu, kvm, id);
700 if (rc)
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);
705
706 return vcpu;
707out_free_sie_block:
708 free_page((unsigned long)(vcpu->arch.sie_block));
709out_free_cpu:
710 kmem_cache_free(kvm_vcpu_cache, vcpu);
711out:
712 return ERR_PTR(rc);
713}
714
715int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
716{
717 return kvm_cpu_has_interrupt(vcpu);
718}
719
720void s390_vcpu_block(struct kvm_vcpu *vcpu)
721{
722 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
723}
724
725void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
726{
727 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
728}
729
730/*
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. */
734void exit_sie(struct kvm_vcpu *vcpu)
735{
736 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
737 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
738 cpu_relax();
739}
740
741/* Kick a guest cpu out of SIE and prevent SIE-reentry */
742void exit_sie_sync(struct kvm_vcpu *vcpu)
743{
744 s390_vcpu_block(vcpu);
745 exit_sie(vcpu);
746}
747
748static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
749{
750 int i;
751 struct kvm *kvm = gmap->private;
752 struct kvm_vcpu *vcpu;
753
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);
759 exit_sie_sync(vcpu);
760 }
761 }
762}
763
764int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
765{
766 /* kvm common code refers to this, but never calls it */
767 BUG();
768 return 0;
769}
770
771static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
772 struct kvm_one_reg *reg)
773{
774 int r = -EINVAL;
775
776 switch (reg->id) {
777 case KVM_REG_S390_TODPR:
778 r = put_user(vcpu->arch.sie_block->todpr,
779 (u32 __user *)reg->addr);
780 break;
781 case KVM_REG_S390_EPOCHDIFF:
782 r = put_user(vcpu->arch.sie_block->epoch,
783 (u64 __user *)reg->addr);
784 break;
785 case KVM_REG_S390_CPU_TIMER:
786 r = put_user(vcpu->arch.sie_block->cputm,
787 (u64 __user *)reg->addr);
788 break;
789 case KVM_REG_S390_CLOCK_COMP:
790 r = put_user(vcpu->arch.sie_block->ckc,
791 (u64 __user *)reg->addr);
792 break;
793 case KVM_REG_S390_PFTOKEN:
794 r = put_user(vcpu->arch.pfault_token,
795 (u64 __user *)reg->addr);
796 break;
797 case KVM_REG_S390_PFCOMPARE:
798 r = put_user(vcpu->arch.pfault_compare,
799 (u64 __user *)reg->addr);
800 break;
801 case KVM_REG_S390_PFSELECT:
802 r = put_user(vcpu->arch.pfault_select,
803 (u64 __user *)reg->addr);
804 break;
805 case KVM_REG_S390_PP:
806 r = put_user(vcpu->arch.sie_block->pp,
807 (u64 __user *)reg->addr);
808 break;
809 case KVM_REG_S390_GBEA:
810 r = put_user(vcpu->arch.sie_block->gbea,
811 (u64 __user *)reg->addr);
812 break;
813 default:
814 break;
815 }
816
817 return r;
818}
819
820static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
821 struct kvm_one_reg *reg)
822{
823 int r = -EINVAL;
824
825 switch (reg->id) {
826 case KVM_REG_S390_TODPR:
827 r = get_user(vcpu->arch.sie_block->todpr,
828 (u32 __user *)reg->addr);
829 break;
830 case KVM_REG_S390_EPOCHDIFF:
831 r = get_user(vcpu->arch.sie_block->epoch,
832 (u64 __user *)reg->addr);
833 break;
834 case KVM_REG_S390_CPU_TIMER:
835 r = get_user(vcpu->arch.sie_block->cputm,
836 (u64 __user *)reg->addr);
837 break;
838 case KVM_REG_S390_CLOCK_COMP:
839 r = get_user(vcpu->arch.sie_block->ckc,
840 (u64 __user *)reg->addr);
841 break;
842 case KVM_REG_S390_PFTOKEN:
843 r = get_user(vcpu->arch.pfault_token,
844 (u64 __user *)reg->addr);
845 break;
846 case KVM_REG_S390_PFCOMPARE:
847 r = get_user(vcpu->arch.pfault_compare,
848 (u64 __user *)reg->addr);
849 break;
850 case KVM_REG_S390_PFSELECT:
851 r = get_user(vcpu->arch.pfault_select,
852 (u64 __user *)reg->addr);
853 break;
854 case KVM_REG_S390_PP:
855 r = get_user(vcpu->arch.sie_block->pp,
856 (u64 __user *)reg->addr);
857 break;
858 case KVM_REG_S390_GBEA:
859 r = get_user(vcpu->arch.sie_block->gbea,
860 (u64 __user *)reg->addr);
861 break;
862 default:
863 break;
864 }
865
866 return r;
867}
868
869static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
870{
871 kvm_s390_vcpu_initial_reset(vcpu);
872 return 0;
873}
874
875int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
876{
877 memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
878 return 0;
879}
880
881int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
882{
883 memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
884 return 0;
885}
886
887int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
888 struct kvm_sregs *sregs)
889{
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);
893 return 0;
894}
895
896int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
897 struct kvm_sregs *sregs)
898{
899 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
900 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
901 return 0;
902}
903
904int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
905{
906 if (test_fp_ctl(fpu->fpc))
907 return -EINVAL;
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);
912 return 0;
913}
914
915int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
916{
917 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
918 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
919 return 0;
920}
921
922static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
923{
924 int rc = 0;
925
926 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
927 rc = -EBUSY;
928 else {
929 vcpu->run->psw_mask = psw.mask;
930 vcpu->run->psw_addr = psw.addr;
931 }
932 return rc;
933}
934
935int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
936 struct kvm_translation *tr)
937{
938 return -EINVAL; /* not implemented yet */
939}
940
941#define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \
942 KVM_GUESTDBG_USE_HW_BP | \
943 KVM_GUESTDBG_ENABLE)
944
945int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
946 struct kvm_guest_debug *dbg)
947{
948 int rc = 0;
949
950 vcpu->guest_debug = 0;
951 kvm_s390_clear_bp_data(vcpu);
952
953 if (vcpu->guest_debug & ~VALID_GUESTDBG_FLAGS)
954 return -EINVAL;
955
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);
960
961 if (dbg->control & KVM_GUESTDBG_USE_HW_BP)
962 rc = kvm_s390_import_bp_data(vcpu, dbg);
963 } else {
964 atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
965 vcpu->arch.guestdbg.last_bp = 0;
966 }
967
968 if (rc) {
969 vcpu->guest_debug = 0;
970 kvm_s390_clear_bp_data(vcpu);
971 atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
972 }
973
974 return rc;
975}
976
977int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
978 struct kvm_mp_state *mp_state)
979{
980 return -EINVAL; /* not implemented yet */
981}
982
983int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
984 struct kvm_mp_state *mp_state)
985{
986 return -EINVAL; /* not implemented yet */
987}
988
989bool kvm_s390_cmma_enabled(struct kvm *kvm)
990{
991 if (!MACHINE_IS_LPAR)
992 return false;
993 /* only enable for z10 and later */
994 if (!MACHINE_HAS_EDAT1)
995 return false;
996 if (!kvm->arch.use_cmma)
997 return false;
998 return true;
999}
1000
1001static bool ibs_enabled(struct kvm_vcpu *vcpu)
1002{
1003 return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS;
1004}
1005
1006static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
1007{
1008retry:
1009 s390_vcpu_unblock(vcpu);
1010 /*
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.
1016 */
1017 if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
1018 int rc;
1019 rc = gmap_ipte_notify(vcpu->arch.gmap,
1020 vcpu->arch.sie_block->prefix,
1021 PAGE_SIZE * 2);
1022 if (rc)
1023 return rc;
1024 goto retry;
1025 }
1026
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);
1032 }
1033 goto retry;
1034 }
1035
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);
1041 }
1042 goto retry;
1043 }
1044
1045 return 0;
1046}
1047
1048static long kvm_arch_fault_in_sync(struct kvm_vcpu *vcpu)
1049{
1050 long rc;
1051 hva_t fault = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap);
1052 struct mm_struct *mm = current->mm;
1053 down_read(&mm->mmap_sem);
1054 rc = get_user_pages(current, mm, fault, 1, 1, 0, NULL, NULL);
1055 up_read(&mm->mmap_sem);
1056 return rc;
1057}
1058
1059static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
1060 unsigned long token)
1061{
1062 struct kvm_s390_interrupt inti;
1063 inti.parm64 = token;
1064
1065 if (start_token) {
1066 inti.type = KVM_S390_INT_PFAULT_INIT;
1067 WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &inti));
1068 } else {
1069 inti.type = KVM_S390_INT_PFAULT_DONE;
1070 WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
1071 }
1072}
1073
1074void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
1075 struct kvm_async_pf *work)
1076{
1077 trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
1078 __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
1079}
1080
1081void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
1082 struct kvm_async_pf *work)
1083{
1084 trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
1085 __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
1086}
1087
1088void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
1089 struct kvm_async_pf *work)
1090{
1091 /* s390 will always inject the page directly */
1092}
1093
1094bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
1095{
1096 /*
1097 * s390 will always inject the page directly,
1098 * but we still want check_async_completion to cleanup
1099 */
1100 return true;
1101}
1102
1103static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
1104{
1105 hva_t hva;
1106 struct kvm_arch_async_pf arch;
1107 int rc;
1108
1109 if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
1110 return 0;
1111 if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
1112 vcpu->arch.pfault_compare)
1113 return 0;
1114 if (psw_extint_disabled(vcpu))
1115 return 0;
1116 if (kvm_cpu_has_interrupt(vcpu))
1117 return 0;
1118 if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul))
1119 return 0;
1120 if (!vcpu->arch.gmap->pfault_enabled)
1121 return 0;
1122
1123 hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr));
1124 hva += current->thread.gmap_addr & ~PAGE_MASK;
1125 if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8))
1126 return 0;
1127
1128 rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
1129 return rc;
1130}
1131
1132static int vcpu_pre_run(struct kvm_vcpu *vcpu)
1133{
1134 int rc, cpuflags;
1135
1136 /*
1137 * On s390 notifications for arriving pages will be delivered directly
1138 * to the guest but the house keeping for completed pfaults is
1139 * handled outside the worker.
1140 */
1141 kvm_check_async_pf_completion(vcpu);
1142
1143 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
1144
1145 if (need_resched())
1146 schedule();
1147
1148 if (test_thread_flag(TIF_MCCK_PENDING))
1149 s390_handle_mcck();
1150
1151 if (!kvm_is_ucontrol(vcpu->kvm))
1152 kvm_s390_deliver_pending_interrupts(vcpu);
1153
1154 rc = kvm_s390_handle_requests(vcpu);
1155 if (rc)
1156 return rc;
1157
1158 if (guestdbg_enabled(vcpu)) {
1159 kvm_s390_backup_guest_per_regs(vcpu);
1160 kvm_s390_patch_guest_per_regs(vcpu);
1161 }
1162
1163 vcpu->arch.sie_block->icptcode = 0;
1164 cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
1165 VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
1166 trace_kvm_s390_sie_enter(vcpu, cpuflags);
1167
1168 return 0;
1169}
1170
1171static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
1172{
1173 int rc = -1;
1174
1175 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
1176 vcpu->arch.sie_block->icptcode);
1177 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
1178
1179 if (guestdbg_enabled(vcpu))
1180 kvm_s390_restore_guest_per_regs(vcpu);
1181
1182 if (exit_reason >= 0) {
1183 rc = 0;
1184 } else if (kvm_is_ucontrol(vcpu->kvm)) {
1185 vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
1186 vcpu->run->s390_ucontrol.trans_exc_code =
1187 current->thread.gmap_addr;
1188 vcpu->run->s390_ucontrol.pgm_code = 0x10;
1189 rc = -EREMOTE;
1190
1191 } else if (current->thread.gmap_pfault) {
1192 trace_kvm_s390_major_guest_pfault(vcpu);
1193 current->thread.gmap_pfault = 0;
1194 if (kvm_arch_setup_async_pf(vcpu) ||
1195 (kvm_arch_fault_in_sync(vcpu) >= 0))
1196 rc = 0;
1197 }
1198
1199 if (rc == -1) {
1200 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
1201 trace_kvm_s390_sie_fault(vcpu);
1202 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
1203 }
1204
1205 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
1206
1207 if (rc == 0) {
1208 if (kvm_is_ucontrol(vcpu->kvm))
1209 /* Don't exit for host interrupts. */
1210 rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0;
1211 else
1212 rc = kvm_handle_sie_intercept(vcpu);
1213 }
1214
1215 return rc;
1216}
1217
1218static int __vcpu_run(struct kvm_vcpu *vcpu)
1219{
1220 int rc, exit_reason;
1221
1222 /*
1223 * We try to hold kvm->srcu during most of vcpu_run (except when run-
1224 * ning the guest), so that memslots (and other stuff) are protected
1225 */
1226 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
1227
1228 do {
1229 rc = vcpu_pre_run(vcpu);
1230 if (rc)
1231 break;
1232
1233 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
1234 /*
1235 * As PF_VCPU will be used in fault handler, between
1236 * guest_enter and guest_exit should be no uaccess.
1237 */
1238 preempt_disable();
1239 kvm_guest_enter();
1240 preempt_enable();
1241 exit_reason = sie64a(vcpu->arch.sie_block,
1242 vcpu->run->s.regs.gprs);
1243 kvm_guest_exit();
1244 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
1245
1246 rc = vcpu_post_run(vcpu, exit_reason);
1247 } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc);
1248
1249 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
1250 return rc;
1251}
1252
1253int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1254{
1255 int rc;
1256 sigset_t sigsaved;
1257
1258 if (guestdbg_exit_pending(vcpu)) {
1259 kvm_s390_prepare_debug_exit(vcpu);
1260 return 0;
1261 }
1262
1263 if (vcpu->sigset_active)
1264 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
1265
1266 kvm_s390_vcpu_start(vcpu);
1267
1268 switch (kvm_run->exit_reason) {
1269 case KVM_EXIT_S390_SIEIC:
1270 case KVM_EXIT_UNKNOWN:
1271 case KVM_EXIT_INTR:
1272 case KVM_EXIT_S390_RESET:
1273 case KVM_EXIT_S390_UCONTROL:
1274 case KVM_EXIT_S390_TSCH:
1275 case KVM_EXIT_DEBUG:
1276 break;
1277 default:
1278 BUG();
1279 }
1280
1281 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
1282 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
1283 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
1284 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
1285 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1286 }
1287 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
1288 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
1289 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
1290 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1291 }
1292
1293 might_fault();
1294 rc = __vcpu_run(vcpu);
1295
1296 if (signal_pending(current) && !rc) {
1297 kvm_run->exit_reason = KVM_EXIT_INTR;
1298 rc = -EINTR;
1299 }
1300
1301 if (guestdbg_exit_pending(vcpu) && !rc) {
1302 kvm_s390_prepare_debug_exit(vcpu);
1303 rc = 0;
1304 }
1305
1306 if (rc == -EOPNOTSUPP) {
1307 /* intercept cannot be handled in-kernel, prepare kvm-run */
1308 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
1309 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
1310 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
1311 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
1312 rc = 0;
1313 }
1314
1315 if (rc == -EREMOTE) {
1316 /* intercept was handled, but userspace support is needed
1317 * kvm_run has been prepared by the handler */
1318 rc = 0;
1319 }
1320
1321 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
1322 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
1323 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
1324 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
1325
1326 if (vcpu->sigset_active)
1327 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1328
1329 vcpu->stat.exit_userspace++;
1330 return rc;
1331}
1332
1333/*
1334 * store status at address
1335 * we use have two special cases:
1336 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
1337 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
1338 */
1339int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa)
1340{
1341 unsigned char archmode = 1;
1342 u64 clkcomp;
1343 int rc;
1344
1345 if (gpa == KVM_S390_STORE_STATUS_NOADDR) {
1346 if (write_guest_abs(vcpu, 163, &archmode, 1))
1347 return -EFAULT;
1348 gpa = SAVE_AREA_BASE;
1349 } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) {
1350 if (write_guest_real(vcpu, 163, &archmode, 1))
1351 return -EFAULT;
1352 gpa = kvm_s390_real_to_abs(vcpu, SAVE_AREA_BASE);
1353 }
1354 rc = write_guest_abs(vcpu, gpa + offsetof(struct save_area, fp_regs),
1355 vcpu->arch.guest_fpregs.fprs, 128);
1356 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, gp_regs),
1357 vcpu->run->s.regs.gprs, 128);
1358 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, psw),
1359 &vcpu->arch.sie_block->gpsw, 16);
1360 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, pref_reg),
1361 &vcpu->arch.sie_block->prefix, 4);
1362 rc |= write_guest_abs(vcpu,
1363 gpa + offsetof(struct save_area, fp_ctrl_reg),
1364 &vcpu->arch.guest_fpregs.fpc, 4);
1365 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, tod_reg),
1366 &vcpu->arch.sie_block->todpr, 4);
1367 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, timer),
1368 &vcpu->arch.sie_block->cputm, 8);
1369 clkcomp = vcpu->arch.sie_block->ckc >> 8;
1370 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, clk_cmp),
1371 &clkcomp, 8);
1372 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, acc_regs),
1373 &vcpu->run->s.regs.acrs, 64);
1374 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, ctrl_regs),
1375 &vcpu->arch.sie_block->gcr, 128);
1376 return rc ? -EFAULT : 0;
1377}
1378
1379int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
1380{
1381 /*
1382 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
1383 * copying in vcpu load/put. Lets update our copies before we save
1384 * it into the save area
1385 */
1386 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1387 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
1388 save_access_regs(vcpu->run->s.regs.acrs);
1389
1390 return kvm_s390_store_status_unloaded(vcpu, addr);
1391}
1392
1393static inline int is_vcpu_stopped(struct kvm_vcpu *vcpu)
1394{
1395 return atomic_read(&(vcpu)->arch.sie_block->cpuflags) & CPUSTAT_STOPPED;
1396}
1397
1398static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
1399{
1400 kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu);
1401 kvm_make_request(KVM_REQ_DISABLE_IBS, vcpu);
1402 exit_sie_sync(vcpu);
1403}
1404
1405static void __disable_ibs_on_all_vcpus(struct kvm *kvm)
1406{
1407 unsigned int i;
1408 struct kvm_vcpu *vcpu;
1409
1410 kvm_for_each_vcpu(i, vcpu, kvm) {
1411 __disable_ibs_on_vcpu(vcpu);
1412 }
1413}
1414
1415static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
1416{
1417 kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu);
1418 kvm_make_request(KVM_REQ_ENABLE_IBS, vcpu);
1419 exit_sie_sync(vcpu);
1420}
1421
1422void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu)
1423{
1424 int i, online_vcpus, started_vcpus = 0;
1425
1426 if (!is_vcpu_stopped(vcpu))
1427 return;
1428
1429 trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1);
1430 /* Only one cpu at a time may enter/leave the STOPPED state. */
1431 spin_lock_bh(&vcpu->kvm->arch.start_stop_lock);
1432 online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
1433
1434 for (i = 0; i < online_vcpus; i++) {
1435 if (!is_vcpu_stopped(vcpu->kvm->vcpus[i]))
1436 started_vcpus++;
1437 }
1438
1439 if (started_vcpus == 0) {
1440 /* we're the only active VCPU -> speed it up */
1441 __enable_ibs_on_vcpu(vcpu);
1442 } else if (started_vcpus == 1) {
1443 /*
1444 * As we are starting a second VCPU, we have to disable
1445 * the IBS facility on all VCPUs to remove potentially
1446 * oustanding ENABLE requests.
1447 */
1448 __disable_ibs_on_all_vcpus(vcpu->kvm);
1449 }
1450
1451 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
1452 /*
1453 * Another VCPU might have used IBS while we were offline.
1454 * Let's play safe and flush the VCPU at startup.
1455 */
1456 vcpu->arch.sie_block->ihcpu = 0xffff;
1457 spin_unlock_bh(&vcpu->kvm->arch.start_stop_lock);
1458 return;
1459}
1460
1461void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu)
1462{
1463 int i, online_vcpus, started_vcpus = 0;
1464 struct kvm_vcpu *started_vcpu = NULL;
1465
1466 if (is_vcpu_stopped(vcpu))
1467 return;
1468
1469 trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0);
1470 /* Only one cpu at a time may enter/leave the STOPPED state. */
1471 spin_lock_bh(&vcpu->kvm->arch.start_stop_lock);
1472 online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
1473
1474 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
1475 __disable_ibs_on_vcpu(vcpu);
1476
1477 for (i = 0; i < online_vcpus; i++) {
1478 if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) {
1479 started_vcpus++;
1480 started_vcpu = vcpu->kvm->vcpus[i];
1481 }
1482 }
1483
1484 if (started_vcpus == 1) {
1485 /*
1486 * As we only have one VCPU left, we want to enable the
1487 * IBS facility for that VCPU to speed it up.
1488 */
1489 __enable_ibs_on_vcpu(started_vcpu);
1490 }
1491
1492 spin_unlock_bh(&vcpu->kvm->arch.start_stop_lock);
1493 return;
1494}
1495
1496static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
1497 struct kvm_enable_cap *cap)
1498{
1499 int r;
1500
1501 if (cap->flags)
1502 return -EINVAL;
1503
1504 switch (cap->cap) {
1505 case KVM_CAP_S390_CSS_SUPPORT:
1506 if (!vcpu->kvm->arch.css_support) {
1507 vcpu->kvm->arch.css_support = 1;
1508 trace_kvm_s390_enable_css(vcpu->kvm);
1509 }
1510 r = 0;
1511 break;
1512 default:
1513 r = -EINVAL;
1514 break;
1515 }
1516 return r;
1517}
1518
1519long kvm_arch_vcpu_ioctl(struct file *filp,
1520 unsigned int ioctl, unsigned long arg)
1521{
1522 struct kvm_vcpu *vcpu = filp->private_data;
1523 void __user *argp = (void __user *)arg;
1524 int idx;
1525 long r;
1526
1527 switch (ioctl) {
1528 case KVM_S390_INTERRUPT: {
1529 struct kvm_s390_interrupt s390int;
1530
1531 r = -EFAULT;
1532 if (copy_from_user(&s390int, argp, sizeof(s390int)))
1533 break;
1534 r = kvm_s390_inject_vcpu(vcpu, &s390int);
1535 break;
1536 }
1537 case KVM_S390_STORE_STATUS:
1538 idx = srcu_read_lock(&vcpu->kvm->srcu);
1539 r = kvm_s390_vcpu_store_status(vcpu, arg);
1540 srcu_read_unlock(&vcpu->kvm->srcu, idx);
1541 break;
1542 case KVM_S390_SET_INITIAL_PSW: {
1543 psw_t psw;
1544
1545 r = -EFAULT;
1546 if (copy_from_user(&psw, argp, sizeof(psw)))
1547 break;
1548 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
1549 break;
1550 }
1551 case KVM_S390_INITIAL_RESET:
1552 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
1553 break;
1554 case KVM_SET_ONE_REG:
1555 case KVM_GET_ONE_REG: {
1556 struct kvm_one_reg reg;
1557 r = -EFAULT;
1558 if (copy_from_user(&reg, argp, sizeof(reg)))
1559 break;
1560 if (ioctl == KVM_SET_ONE_REG)
1561 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
1562 else
1563 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
1564 break;
1565 }
1566#ifdef CONFIG_KVM_S390_UCONTROL
1567 case KVM_S390_UCAS_MAP: {
1568 struct kvm_s390_ucas_mapping ucasmap;
1569
1570 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1571 r = -EFAULT;
1572 break;
1573 }
1574
1575 if (!kvm_is_ucontrol(vcpu->kvm)) {
1576 r = -EINVAL;
1577 break;
1578 }
1579
1580 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
1581 ucasmap.vcpu_addr, ucasmap.length);
1582 break;
1583 }
1584 case KVM_S390_UCAS_UNMAP: {
1585 struct kvm_s390_ucas_mapping ucasmap;
1586
1587 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1588 r = -EFAULT;
1589 break;
1590 }
1591
1592 if (!kvm_is_ucontrol(vcpu->kvm)) {
1593 r = -EINVAL;
1594 break;
1595 }
1596
1597 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
1598 ucasmap.length);
1599 break;
1600 }
1601#endif
1602 case KVM_S390_VCPU_FAULT: {
1603 r = gmap_fault(arg, vcpu->arch.gmap);
1604 if (!IS_ERR_VALUE(r))
1605 r = 0;
1606 break;
1607 }
1608 case KVM_ENABLE_CAP:
1609 {
1610 struct kvm_enable_cap cap;
1611 r = -EFAULT;
1612 if (copy_from_user(&cap, argp, sizeof(cap)))
1613 break;
1614 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1615 break;
1616 }
1617 default:
1618 r = -ENOTTY;
1619 }
1620 return r;
1621}
1622
1623int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1624{
1625#ifdef CONFIG_KVM_S390_UCONTROL
1626 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
1627 && (kvm_is_ucontrol(vcpu->kvm))) {
1628 vmf->page = virt_to_page(vcpu->arch.sie_block);
1629 get_page(vmf->page);
1630 return 0;
1631 }
1632#endif
1633 return VM_FAULT_SIGBUS;
1634}
1635
1636void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
1637 struct kvm_memory_slot *dont)
1638{
1639}
1640
1641int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
1642 unsigned long npages)
1643{
1644 return 0;
1645}
1646
1647void kvm_arch_memslots_updated(struct kvm *kvm)
1648{
1649}
1650
1651/* Section: memory related */
1652int kvm_arch_prepare_memory_region(struct kvm *kvm,
1653 struct kvm_memory_slot *memslot,
1654 struct kvm_userspace_memory_region *mem,
1655 enum kvm_mr_change change)
1656{
1657 /* A few sanity checks. We can have memory slots which have to be
1658 located/ended at a segment boundary (1MB). The memory in userland is
1659 ok to be fragmented into various different vmas. It is okay to mmap()
1660 and munmap() stuff in this slot after doing this call at any time */
1661
1662 if (mem->userspace_addr & 0xffffful)
1663 return -EINVAL;
1664
1665 if (mem->memory_size & 0xffffful)
1666 return -EINVAL;
1667
1668 return 0;
1669}
1670
1671void kvm_arch_commit_memory_region(struct kvm *kvm,
1672 struct kvm_userspace_memory_region *mem,
1673 const struct kvm_memory_slot *old,
1674 enum kvm_mr_change change)
1675{
1676 int rc;
1677
1678 /* If the basics of the memslot do not change, we do not want
1679 * to update the gmap. Every update causes several unnecessary
1680 * segment translation exceptions. This is usually handled just
1681 * fine by the normal fault handler + gmap, but it will also
1682 * cause faults on the prefix page of running guest CPUs.
1683 */
1684 if (old->userspace_addr == mem->userspace_addr &&
1685 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1686 old->npages * PAGE_SIZE == mem->memory_size)
1687 return;
1688
1689 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1690 mem->guest_phys_addr, mem->memory_size);
1691 if (rc)
1692 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
1693 return;
1694}
1695
1696void kvm_arch_flush_shadow_all(struct kvm *kvm)
1697{
1698}
1699
1700void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1701 struct kvm_memory_slot *slot)
1702{
1703}
1704
1705static int __init kvm_s390_init(void)
1706{
1707 int ret;
1708 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1709 if (ret)
1710 return ret;
1711
1712 /*
1713 * guests can ask for up to 255+1 double words, we need a full page
1714 * to hold the maximum amount of facilities. On the other hand, we
1715 * only set facilities that are known to work in KVM.
1716 */
1717 vfacilities = (unsigned long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1718 if (!vfacilities) {
1719 kvm_exit();
1720 return -ENOMEM;
1721 }
1722 memcpy(vfacilities, S390_lowcore.stfle_fac_list, 16);
1723 vfacilities[0] &= 0xff82fff3f4fc2000UL;
1724 vfacilities[1] &= 0x005c000000000000UL;
1725 return 0;
1726}
1727
1728static void __exit kvm_s390_exit(void)
1729{
1730 free_page((unsigned long) vfacilities);
1731 kvm_exit();
1732}
1733
1734module_init(kvm_s390_init);
1735module_exit(kvm_s390_exit);
1736
1737/*
1738 * Enable autoloading of the kvm module.
1739 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
1740 * since x86 takes a different approach.
1741 */
1742#include <linux/miscdevice.h>
1743MODULE_ALIAS_MISCDEV(KVM_MINOR);
1744MODULE_ALIAS("devname:kvm");
Ubuntu Jammy Linux kernel mirror