]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - arch/s390/kvm/kvm-s390.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
KVM: s390: Add proper dirty bitmap support to S390 kvm.
[mirror_ubuntu-artful-kernel.git] / arch / s390 / kvm / kvm-s390.c
CommitLineData
b0c632db 1/*
a53c8fab 2 * hosting zSeries kernel virtual machines
b0c632db 3 *
a53c8fab 4 * Copyright IBM Corp. 2008, 2009
b0c632db
HC		 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>
628eb9b8 13 * Christian Ehrhardt <ehrhardt@de.ibm.com>
15f36ebd 14 * Jason J. Herne <jjherne@us.ibm.com>
b0c632db
HC		 15 */
16
17#include <linux/compiler.h>
18#include <linux/err.h>
19#include <linux/fs.h>
ca872302 20#include <linux/hrtimer.h>
b0c632db
HC		 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>
ba5c1e9b 26#include <linux/timer.h>
cbb870c8 27#include <asm/asm-offsets.h>
b0c632db
HC		 28#include <asm/lowcore.h>
29#include <asm/pgtable.h>
f5daba1d 30#include <asm/nmi.h>
a0616cde 31#include <asm/switch_to.h>
78c4b59f 32#include <asm/facility.h>
1526bf9c 33#include <asm/sclp.h>
8f2abe6a 34#include "kvm-s390.h"
b0c632db
HC		 35#include "gaccess.h"
36
5786fffa
CH		 37#define CREATE_TRACE_POINTS
38#include "trace.h"
ade38c31 39#include "trace-s390.h"
5786fffa 40
b0c632db
HC		 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) },
0eaeafa1 45 { "exit_null", VCPU_STAT(exit_null) },
8f2abe6a
CB		 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) },
ba5c1e9b
CO		 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) },
f5e10b09 53 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
ba5c1e9b
CO		 54 { "instruction_lctl", VCPU_STAT(instruction_lctl) },
55 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
7697e71f 56 { "deliver_external_call", VCPU_STAT(deliver_external_call) },
ba5c1e9b
CO		 57 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
58 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
59 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
60 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
61 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
62 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
63 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
69d0d3a3 64 { "instruction_pfmf", VCPU_STAT(instruction_pfmf) },
453423dc
CB		 65 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
66 { "instruction_spx", VCPU_STAT(instruction_spx) },
67 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
68 { "instruction_stap", VCPU_STAT(instruction_stap) },
69 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
70 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
71 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
b31288fa 72 { "instruction_essa", VCPU_STAT(instruction_essa) },
453423dc
CB		 73 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
74 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
bb25b9ba 75 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
5288fbf0 76 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
bd59d3a4 77 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
7697e71f 78 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
5288fbf0
CB		 79 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
80 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
81 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
82 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
83 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
388186bc 84 { "diagnose_10", VCPU_STAT(diagnose_10) },
e28acfea 85 { "diagnose_44", VCPU_STAT(diagnose_44) },
41628d33 86 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
b0c632db
HC		 87 { NULL }
88};
89
78c4b59f 90unsigned long *vfacilities;
2c70fe44 91static struct gmap_notifier gmap_notifier;
b0c632db 92
78c4b59f
MM		 93/* test availability of vfacility */
94static inline int test_vfacility(unsigned long nr)
95{
96 return __test_facility(nr, (void *) vfacilities);
97}
98
b0c632db 99/* Section: not file related */
10474ae8 100int kvm_arch_hardware_enable(void *garbage)
b0c632db
HC		 101{
102 /* every s390 is virtualization enabled ;-) */
10474ae8 103 return 0;
b0c632db
HC		 104}
105
106void kvm_arch_hardware_disable(void *garbage)
107{
108}
109
2c70fe44
CB		 110static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
111
b0c632db
HC		 112int kvm_arch_hardware_setup(void)
113{
2c70fe44
CB		 114 gmap_notifier.notifier_call = kvm_gmap_notifier;
115 gmap_register_ipte_notifier(&gmap_notifier);
b0c632db
HC		 116 return 0;
117}
118
119void kvm_arch_hardware_unsetup(void)
120{
2c70fe44 121 gmap_unregister_ipte_notifier(&gmap_notifier);
b0c632db
HC		 122}
123
124void kvm_arch_check_processor_compat(void *rtn)
125{
126}
127
128int kvm_arch_init(void *opaque)
129{
130 return 0;
131}
132
133void kvm_arch_exit(void)
134{
135}
136
137/* Section: device related */
138long kvm_arch_dev_ioctl(struct file *filp,
139 unsigned int ioctl, unsigned long arg)
140{
141 if (ioctl == KVM_S390_ENABLE_SIE)
142 return s390_enable_sie();
143 return -EINVAL;
144}
145
146int kvm_dev_ioctl_check_extension(long ext)
147{
d7b0b5eb
CO		 148 int r;
149
2bd0ac4e 150 switch (ext) {
d7b0b5eb 151 case KVM_CAP_S390_PSW:
b6cf8788 152 case KVM_CAP_S390_GMAP:
52e16b18 153 case KVM_CAP_SYNC_MMU:
1efd0f59
CO		 154#ifdef CONFIG_KVM_S390_UCONTROL
155 case KVM_CAP_S390_UCONTROL:
156#endif
3c038e6b 157 case KVM_CAP_ASYNC_PF:
60b413c9 158 case KVM_CAP_SYNC_REGS:
14eebd91 159 case KVM_CAP_ONE_REG:
d6712df9 160 case KVM_CAP_ENABLE_CAP:
fa6b7fe9 161 case KVM_CAP_S390_CSS_SUPPORT:
10ccaa1e 162 case KVM_CAP_IOEVENTFD:
c05c4186 163 case KVM_CAP_DEVICE_CTRL:
d938dc55 164 case KVM_CAP_ENABLE_CAP_VM:
d7b0b5eb
CO		 165 r = 1;
166 break;
e726b1bd
CB		 167 case KVM_CAP_NR_VCPUS:
168 case KVM_CAP_MAX_VCPUS:
169 r = KVM_MAX_VCPUS;
170 break;
e1e2e605
NW		 171 case KVM_CAP_NR_MEMSLOTS:
172 r = KVM_USER_MEM_SLOTS;
173 break;
1526bf9c 174 case KVM_CAP_S390_COW:
abf09bed 175 r = MACHINE_HAS_ESOP;
1526bf9c 176 break;
2bd0ac4e 177 default:
d7b0b5eb 178 r = 0;
2bd0ac4e 179 }
d7b0b5eb 180 return r;
b0c632db
HC		 181}
182
15f36ebd
JH		 183static void kvm_s390_sync_dirty_log(struct kvm *kvm,
184 struct kvm_memory_slot *memslot)
185{
186 gfn_t cur_gfn, last_gfn;
187 unsigned long address;
188 struct gmap *gmap = kvm->arch.gmap;
189
190 down_read(&gmap->mm->mmap_sem);
191 /* Loop over all guest pages */
192 last_gfn = memslot->base_gfn + memslot->npages;
193 for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) {
194 address = gfn_to_hva_memslot(memslot, cur_gfn);
195
196 if (gmap_test_and_clear_dirty(address, gmap))
197 mark_page_dirty(kvm, cur_gfn);
198 }
199 up_read(&gmap->mm->mmap_sem);
200}
201
b0c632db
HC		 202/* Section: vm related */
203/*
204 * Get (and clear) the dirty memory log for a memory slot.
205 */
206int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
207 struct kvm_dirty_log *log)
208{
15f36ebd
JH		 209 int r;
210 unsigned long n;
211 struct kvm_memory_slot *memslot;
212 int is_dirty = 0;
213
214 mutex_lock(&kvm->slots_lock);
215
216 r = -EINVAL;
217 if (log->slot >= KVM_USER_MEM_SLOTS)
218 goto out;
219
220 memslot = id_to_memslot(kvm->memslots, log->slot);
221 r = -ENOENT;
222 if (!memslot->dirty_bitmap)
223 goto out;
224
225 kvm_s390_sync_dirty_log(kvm, memslot);
226 r = kvm_get_dirty_log(kvm, log, &is_dirty);
227 if (r)
228 goto out;
229
230 /* Clear the dirty log */
231 if (is_dirty) {
232 n = kvm_dirty_bitmap_bytes(memslot);
233 memset(memslot->dirty_bitmap, 0, n);
234 }
235 r = 0;
236out:
237 mutex_unlock(&kvm->slots_lock);
238 return r;
b0c632db
HC		 239}
240
d938dc55
CH		 241static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
242{
243 int r;
244
245 if (cap->flags)
246 return -EINVAL;
247
248 switch (cap->cap) {
84223598
CH		 249 case KVM_CAP_S390_IRQCHIP:
250 kvm->arch.use_irqchip = 1;
251 r = 0;
252 break;
d938dc55
CH		 253 default:
254 r = -EINVAL;
255 break;
256 }
257 return r;
258}
259
b0c632db
HC		 260long kvm_arch_vm_ioctl(struct file *filp,
261 unsigned int ioctl, unsigned long arg)
262{
263 struct kvm *kvm = filp->private_data;
264 void __user *argp = (void __user *)arg;
265 int r;
266
267 switch (ioctl) {
ba5c1e9b
CO		 268 case KVM_S390_INTERRUPT: {
269 struct kvm_s390_interrupt s390int;
270
271 r = -EFAULT;
272 if (copy_from_user(&s390int, argp, sizeof(s390int)))
273 break;
274 r = kvm_s390_inject_vm(kvm, &s390int);
275 break;
276 }
d938dc55
CH		 277 case KVM_ENABLE_CAP: {
278 struct kvm_enable_cap cap;
279 r = -EFAULT;
280 if (copy_from_user(&cap, argp, sizeof(cap)))
281 break;
282 r = kvm_vm_ioctl_enable_cap(kvm, &cap);
283 break;
284 }
84223598
CH		 285 case KVM_CREATE_IRQCHIP: {
286 struct kvm_irq_routing_entry routing;
287
288 r = -EINVAL;
289 if (kvm->arch.use_irqchip) {
290 /* Set up dummy routing. */
291 memset(&routing, 0, sizeof(routing));
292 kvm_set_irq_routing(kvm, &routing, 0, 0);
293 r = 0;
294 }
295 break;
296 }
b0c632db 297 default:
367e1319 298 r = -ENOTTY;
b0c632db
HC		 299 }
300
301 return r;
302}
303
e08b9637 304int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
b0c632db 305{
b0c632db
HC		 306 int rc;
307 char debug_name[16];
f6c137ff 308 static unsigned long sca_offset;
b0c632db 309
e08b9637
CO		 310 rc = -EINVAL;
311#ifdef CONFIG_KVM_S390_UCONTROL
312 if (type & ~KVM_VM_S390_UCONTROL)
313 goto out_err;
314 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
315 goto out_err;
316#else
317 if (type)
318 goto out_err;
319#endif
320
b0c632db
HC		 321 rc = s390_enable_sie();
322 if (rc)
d89f5eff 323 goto out_err;
b0c632db 324
b290411a
CO		 325 rc = -ENOMEM;
326
b0c632db
HC		 327 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
328 if (!kvm->arch.sca)
d89f5eff 329 goto out_err;
f6c137ff
CB		 330 spin_lock(&kvm_lock);
331 sca_offset = (sca_offset + 16) & 0x7f0;
332 kvm->arch.sca = (struct sca_block *) ((char *) kvm->arch.sca + sca_offset);
333 spin_unlock(&kvm_lock);
b0c632db
HC		 334
335 sprintf(debug_name, "kvm-%u", current->pid);
336
337 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
338 if (!kvm->arch.dbf)
339 goto out_nodbf;
340
ba5c1e9b
CO		 341 spin_lock_init(&kvm->arch.float_int.lock);
342 INIT_LIST_HEAD(&kvm->arch.float_int.list);
343
b0c632db
HC		 344 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
345 VM_EVENT(kvm, 3, "%s", "vm created");
346
e08b9637
CO		 347 if (type & KVM_VM_S390_UCONTROL) {
348 kvm->arch.gmap = NULL;
349 } else {
350 kvm->arch.gmap = gmap_alloc(current->mm);
351 if (!kvm->arch.gmap)
352 goto out_nogmap;
2c70fe44 353 kvm->arch.gmap->private = kvm;
24eb3a82 354 kvm->arch.gmap->pfault_enabled = 0;
e08b9637 355 }
fa6b7fe9
CH		 356
357 kvm->arch.css_support = 0;
84223598 358 kvm->arch.use_irqchip = 0;
fa6b7fe9 359
d89f5eff 360 return 0;
598841ca
CO		 361out_nogmap:
362 debug_unregister(kvm->arch.dbf);
b0c632db
HC		 363out_nodbf:
364 free_page((unsigned long)(kvm->arch.sca));
d89f5eff
JK		 365out_err:
366 return rc;
b0c632db
HC		 367}
368
d329c035
CB		 369void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
370{
371 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
ade38c31 372 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
3c038e6b 373 kvm_clear_async_pf_completion_queue(vcpu);
58f9460b
CO		 374 if (!kvm_is_ucontrol(vcpu->kvm)) {
375 clear_bit(63 - vcpu->vcpu_id,
376 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
377 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
378 (__u64) vcpu->arch.sie_block)
379 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
380 }
abf4a71e 381 smp_mb();
27e0393f
CO		 382
383 if (kvm_is_ucontrol(vcpu->kvm))
384 gmap_free(vcpu->arch.gmap);
385
b31288fa
KW		 386 if (vcpu->arch.sie_block->cbrlo)
387 __free_page(__pfn_to_page(
388 vcpu->arch.sie_block->cbrlo >> PAGE_SHIFT));
d329c035 389 free_page((unsigned long)(vcpu->arch.sie_block));
b31288fa 390
6692cef3 391 kvm_vcpu_uninit(vcpu);
b110feaf 392 kmem_cache_free(kvm_vcpu_cache, vcpu);
d329c035
CB		 393}
394
395static void kvm_free_vcpus(struct kvm *kvm)
396{
397 unsigned int i;
988a2cae 398 struct kvm_vcpu *vcpu;
d329c035 399
988a2cae
GN		 400 kvm_for_each_vcpu(i, vcpu, kvm)
401 kvm_arch_vcpu_destroy(vcpu);
402
403 mutex_lock(&kvm->lock);
404 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
405 kvm->vcpus[i] = NULL;
406
407 atomic_set(&kvm->online_vcpus, 0);
408 mutex_unlock(&kvm->lock);
d329c035
CB		 409}
410
ad8ba2cd
SY		 411void kvm_arch_sync_events(struct kvm *kvm)
412{
413}
414
b0c632db
HC		 415void kvm_arch_destroy_vm(struct kvm *kvm)
416{
d329c035 417 kvm_free_vcpus(kvm);
b0c632db 418 free_page((unsigned long)(kvm->arch.sca));
d329c035 419 debug_unregister(kvm->arch.dbf);
27e0393f
CO		 420 if (!kvm_is_ucontrol(kvm))
421 gmap_free(kvm->arch.gmap);
841b91c5 422 kvm_s390_destroy_adapters(kvm);
b0c632db
HC		 423}
424
425/* Section: vcpu related */
426int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
427{
3c038e6b
DD		 428 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
429 kvm_clear_async_pf_completion_queue(vcpu);
27e0393f
CO		 430 if (kvm_is_ucontrol(vcpu->kvm)) {
431 vcpu->arch.gmap = gmap_alloc(current->mm);
432 if (!vcpu->arch.gmap)
433 return -ENOMEM;
2c70fe44 434 vcpu->arch.gmap->private = vcpu->kvm;
27e0393f
CO		 435 return 0;
436 }
437
598841ca 438 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
59674c1a
CB		 439 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
440 KVM_SYNC_GPRS |
9eed0735
CB		 441 KVM_SYNC_ACRS |
442 KVM_SYNC_CRS;
b0c632db
HC		 443 return 0;
444}
445
446void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
447{
6692cef3 448 /* Nothing todo */
b0c632db
HC		 449}
450
451void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
452{
4725c860
MS		 453 save_fp_ctl(&vcpu->arch.host_fpregs.fpc);
454 save_fp_regs(vcpu->arch.host_fpregs.fprs);
b0c632db 455 save_access_regs(vcpu->arch.host_acrs);
4725c860
MS		 456 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
457 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
59674c1a 458 restore_access_regs(vcpu->run->s.regs.acrs);
480e5926 459 gmap_enable(vcpu->arch.gmap);
9e6dabef 460 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
b0c632db
HC		 461}
462
463void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
464{
9e6dabef 465 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
480e5926 466 gmap_disable(vcpu->arch.gmap);
4725c860
MS		 467 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
468 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
59674c1a 469 save_access_regs(vcpu->run->s.regs.acrs);
4725c860
MS		 470 restore_fp_ctl(&vcpu->arch.host_fpregs.fpc);
471 restore_fp_regs(vcpu->arch.host_fpregs.fprs);
b0c632db
HC		 472 restore_access_regs(vcpu->arch.host_acrs);
473}
474
475static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
476{
477 /* this equals initial cpu reset in pop, but we don't switch to ESA */
478 vcpu->arch.sie_block->gpsw.mask = 0UL;
479 vcpu->arch.sie_block->gpsw.addr = 0UL;
8d26cf7b 480 kvm_s390_set_prefix(vcpu, 0);
b0c632db
HC		 481 vcpu->arch.sie_block->cputm = 0UL;
482 vcpu->arch.sie_block->ckc = 0UL;
483 vcpu->arch.sie_block->todpr = 0;
484 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
485 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
486 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
487 vcpu->arch.guest_fpregs.fpc = 0;
488 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
489 vcpu->arch.sie_block->gbea = 1;
672550fb 490 vcpu->arch.sie_block->pp = 0;
3c038e6b
DD		 491 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
492 kvm_clear_async_pf_completion_queue(vcpu);
61bde82c 493 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
2ed10cc1 494 kvm_s390_clear_local_irqs(vcpu);
b0c632db
HC		 495}
496
42897d86
MT		 497int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
498{
499 return 0;
500}
501
b0c632db
HC		 502int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
503{
b31288fa
KW		 504 struct page *cbrl;
505
9e6dabef
CH		 506 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
507 CPUSTAT_SM |
69d0d3a3
CB		 508 CPUSTAT_STOPPED |
509 CPUSTAT_GED);
fc34531d 510 vcpu->arch.sie_block->ecb = 6;
7feb6bb8
MM		 511 if (test_vfacility(50) && test_vfacility(73))
512 vcpu->arch.sie_block->ecb |= 0x10;
513
69d0d3a3 514 vcpu->arch.sie_block->ecb2 = 8;
b0c632db 515 vcpu->arch.sie_block->eca = 0xC1002001U;
78c4b59f 516 vcpu->arch.sie_block->fac = (int) (long) vfacilities;
693ffc08 517 vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE;
b31288fa
KW		 518 if (kvm_enabled_cmma()) {
519 cbrl = alloc_page(GFP_KERNEL | __GFP_ZERO);
520 if (cbrl) {
521 vcpu->arch.sie_block->ecb2 |= 0x80;
522 vcpu->arch.sie_block->ecb2 &= ~0x08;
523 vcpu->arch.sie_block->cbrlo = page_to_phys(cbrl);
524 }
525 }
ca872302
CB		 526 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
527 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
528 (unsigned long) vcpu);
529 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
453423dc 530 get_cpu_id(&vcpu->arch.cpu_id);
92e6ecf3 531 vcpu->arch.cpu_id.version = 0xff;
b0c632db
HC		 532 return 0;
533}
534
535struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
536 unsigned int id)
537{
4d47555a 538 struct kvm_vcpu *vcpu;
7feb6bb8 539 struct sie_page *sie_page;
4d47555a
CO		 540 int rc = -EINVAL;
541
542 if (id >= KVM_MAX_VCPUS)
543 goto out;
544
545 rc = -ENOMEM;
b0c632db 546
b110feaf 547 vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
b0c632db 548 if (!vcpu)
4d47555a 549 goto out;
b0c632db 550
7feb6bb8
MM		 551 sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
552 if (!sie_page)
b0c632db
HC		 553 goto out_free_cpu;
554
7feb6bb8
MM		 555 vcpu->arch.sie_block = &sie_page->sie_block;
556 vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;
557
b0c632db 558 vcpu->arch.sie_block->icpua = id;
58f9460b
CO		 559 if (!kvm_is_ucontrol(kvm)) {
560 if (!kvm->arch.sca) {
561 WARN_ON_ONCE(1);
562 goto out_free_cpu;
563 }
564 if (!kvm->arch.sca->cpu[id].sda)
565 kvm->arch.sca->cpu[id].sda =
566 (__u64) vcpu->arch.sie_block;
567 vcpu->arch.sie_block->scaoh =
568 (__u32)(((__u64)kvm->arch.sca) >> 32);
569 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
570 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
571 }
b0c632db 572
ba5c1e9b
CO		 573 spin_lock_init(&vcpu->arch.local_int.lock);
574 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
575 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
d0321a24 576 vcpu->arch.local_int.wq = &vcpu->wq;
5288fbf0 577 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
ba5c1e9b 578
b0c632db
HC		 579 rc = kvm_vcpu_init(vcpu, kvm, id);
580 if (rc)
7b06bf2f 581 goto out_free_sie_block;
b0c632db
HC		 582 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
583 vcpu->arch.sie_block);
ade38c31 584 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
b0c632db 585
b0c632db 586 return vcpu;
7b06bf2f
WY		 587out_free_sie_block:
588 free_page((unsigned long)(vcpu->arch.sie_block));
b0c632db 589out_free_cpu:
b110feaf 590 kmem_cache_free(kvm_vcpu_cache, vcpu);
4d47555a 591out:
b0c632db
HC		 592 return ERR_PTR(rc);
593}
594
b0c632db
HC		 595int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
596{
f87618e8 597 return kvm_cpu_has_interrupt(vcpu);
b0c632db
HC		 598}
599
49b99e1e
CB		 600void s390_vcpu_block(struct kvm_vcpu *vcpu)
601{
602 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
603}
604
605void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
606{
607 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
608}
609
610/*
611 * Kick a guest cpu out of SIE and wait until SIE is not running.
612 * If the CPU is not running (e.g. waiting as idle) the function will
613 * return immediately. */
614void exit_sie(struct kvm_vcpu *vcpu)
615{
616 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
617 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
618 cpu_relax();
619}
620
621/* Kick a guest cpu out of SIE and prevent SIE-reentry */
622void exit_sie_sync(struct kvm_vcpu *vcpu)
623{
624 s390_vcpu_block(vcpu);
625 exit_sie(vcpu);
626}
627
2c70fe44
CB		 628static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
629{
630 int i;
631 struct kvm *kvm = gmap->private;
632 struct kvm_vcpu *vcpu;
633
634 kvm_for_each_vcpu(i, vcpu, kvm) {
635 /* match against both prefix pages */
636 if (vcpu->arch.sie_block->prefix == (address & ~0x1000UL)) {
637 VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
638 kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
639 exit_sie_sync(vcpu);
640 }
641 }
642}
643
b6d33834
CD		 644int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
645{
646 /* kvm common code refers to this, but never calls it */
647 BUG();
648 return 0;
649}
650
14eebd91
CO		 651static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
652 struct kvm_one_reg *reg)
653{
654 int r = -EINVAL;
655
656 switch (reg->id) {
29b7c71b
CO		 657 case KVM_REG_S390_TODPR:
658 r = put_user(vcpu->arch.sie_block->todpr,
659 (u32 __user *)reg->addr);
660 break;
661 case KVM_REG_S390_EPOCHDIFF:
662 r = put_user(vcpu->arch.sie_block->epoch,
663 (u64 __user *)reg->addr);
664 break;
46a6dd1c
J		 665 case KVM_REG_S390_CPU_TIMER:
666 r = put_user(vcpu->arch.sie_block->cputm,
667 (u64 __user *)reg->addr);
668 break;
669 case KVM_REG_S390_CLOCK_COMP:
670 r = put_user(vcpu->arch.sie_block->ckc,
671 (u64 __user *)reg->addr);
672 break;
536336c2
DD		 673 case KVM_REG_S390_PFTOKEN:
674 r = put_user(vcpu->arch.pfault_token,
675 (u64 __user *)reg->addr);
676 break;
677 case KVM_REG_S390_PFCOMPARE:
678 r = put_user(vcpu->arch.pfault_compare,
679 (u64 __user *)reg->addr);
680 break;
681 case KVM_REG_S390_PFSELECT:
682 r = put_user(vcpu->arch.pfault_select,
683 (u64 __user *)reg->addr);
684 break;
672550fb
CB		 685 case KVM_REG_S390_PP:
686 r = put_user(vcpu->arch.sie_block->pp,
687 (u64 __user *)reg->addr);
688 break;
afa45ff5
CB		 689 case KVM_REG_S390_GBEA:
690 r = put_user(vcpu->arch.sie_block->gbea,
691 (u64 __user *)reg->addr);
692 break;
14eebd91
CO		 693 default:
694 break;
695 }
696
697 return r;
698}
699
700static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
701 struct kvm_one_reg *reg)
702{
703 int r = -EINVAL;
704
705 switch (reg->id) {
29b7c71b
CO		 706 case KVM_REG_S390_TODPR:
707 r = get_user(vcpu->arch.sie_block->todpr,
708 (u32 __user *)reg->addr);
709 break;
710 case KVM_REG_S390_EPOCHDIFF:
711 r = get_user(vcpu->arch.sie_block->epoch,
712 (u64 __user *)reg->addr);
713 break;
46a6dd1c
J		 714 case KVM_REG_S390_CPU_TIMER:
715 r = get_user(vcpu->arch.sie_block->cputm,
716 (u64 __user *)reg->addr);
717 break;
718 case KVM_REG_S390_CLOCK_COMP:
719 r = get_user(vcpu->arch.sie_block->ckc,
720 (u64 __user *)reg->addr);
721 break;
536336c2
DD		 722 case KVM_REG_S390_PFTOKEN:
723 r = get_user(vcpu->arch.pfault_token,
724 (u64 __user *)reg->addr);
725 break;
726 case KVM_REG_S390_PFCOMPARE:
727 r = get_user(vcpu->arch.pfault_compare,
728 (u64 __user *)reg->addr);
729 break;
730 case KVM_REG_S390_PFSELECT:
731 r = get_user(vcpu->arch.pfault_select,
732 (u64 __user *)reg->addr);
733 break;
672550fb
CB		 734 case KVM_REG_S390_PP:
735 r = get_user(vcpu->arch.sie_block->pp,
736 (u64 __user *)reg->addr);
737 break;
afa45ff5
CB		 738 case KVM_REG_S390_GBEA:
739 r = get_user(vcpu->arch.sie_block->gbea,
740 (u64 __user *)reg->addr);
741 break;
14eebd91
CO		 742 default:
743 break;
744 }
745
746 return r;
747}
b6d33834 748
b0c632db
HC		 749static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
750{
b0c632db 751 kvm_s390_vcpu_initial_reset(vcpu);
b0c632db
HC		 752 return 0;
753}
754
755int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
756{
5a32c1af 757 memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
b0c632db
HC		 758 return 0;
759}
760
761int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
762{
5a32c1af 763 memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
b0c632db
HC		 764 return 0;
765}
766
767int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
768 struct kvm_sregs *sregs)
769{
59674c1a 770 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
b0c632db 771 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
59674c1a 772 restore_access_regs(vcpu->run->s.regs.acrs);
b0c632db
HC		 773 return 0;
774}
775
776int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
777 struct kvm_sregs *sregs)
778{
59674c1a 779 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
b0c632db 780 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
b0c632db
HC		 781 return 0;
782}
783
784int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
785{
4725c860
MS		 786 if (test_fp_ctl(fpu->fpc))
787 return -EINVAL;
b0c632db 788 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
4725c860
MS		 789 vcpu->arch.guest_fpregs.fpc = fpu->fpc;
790 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
791 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
b0c632db
HC		 792 return 0;
793}
794
795int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
796{
b0c632db
HC		 797 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
798 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
b0c632db
HC		 799 return 0;
800}
801
802static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
803{
804 int rc = 0;
805
9e6dabef 806 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
b0c632db 807 rc = -EBUSY;
d7b0b5eb
CO		 808 else {
809 vcpu->run->psw_mask = psw.mask;
810 vcpu->run->psw_addr = psw.addr;
811 }
b0c632db
HC		 812 return rc;
813}
814
815int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
816 struct kvm_translation *tr)
817{
818 return -EINVAL; /* not implemented yet */
819}
820
d0bfb940
JK		 821int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
822 struct kvm_guest_debug *dbg)
b0c632db
HC		 823{
824 return -EINVAL; /* not implemented yet */
825}
826
62d9f0db
MT		 827int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
828 struct kvm_mp_state *mp_state)
829{
830 return -EINVAL; /* not implemented yet */
831}
832
833int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
834 struct kvm_mp_state *mp_state)
835{
836 return -EINVAL; /* not implemented yet */
837}
838
2c70fe44
CB		 839static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
840{
841 /*
842 * We use MMU_RELOAD just to re-arm the ipte notifier for the
843 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
844 * This ensures that the ipte instruction for this request has
845 * already finished. We might race against a second unmapper that
846 * wants to set the blocking bit. Lets just retry the request loop.
847 */
848 while (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
849 int rc;
850 rc = gmap_ipte_notify(vcpu->arch.gmap,
851 vcpu->arch.sie_block->prefix,
852 PAGE_SIZE * 2);
853 if (rc)
854 return rc;
855 s390_vcpu_unblock(vcpu);
856 }
857 return 0;
858}
859
24eb3a82
DD		 860static long kvm_arch_fault_in_sync(struct kvm_vcpu *vcpu)
861{
862 long rc;
863 hva_t fault = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap);
864 struct mm_struct *mm = current->mm;
865 down_read(&mm->mmap_sem);
866 rc = get_user_pages(current, mm, fault, 1, 1, 0, NULL, NULL);
867 up_read(&mm->mmap_sem);
868 return rc;
869}
870
3c038e6b
DD		 871static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
872 unsigned long token)
873{
874 struct kvm_s390_interrupt inti;
875 inti.parm64 = token;
876
877 if (start_token) {
878 inti.type = KVM_S390_INT_PFAULT_INIT;
879 WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &inti));
880 } else {
881 inti.type = KVM_S390_INT_PFAULT_DONE;
882 WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
883 }
884}
885
886void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
887 struct kvm_async_pf *work)
888{
889 trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
890 __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
891}
892
893void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
894 struct kvm_async_pf *work)
895{
896 trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
897 __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
898}
899
900void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
901 struct kvm_async_pf *work)
902{
903 /* s390 will always inject the page directly */
904}
905
906bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
907{
908 /*
909 * s390 will always inject the page directly,
910 * but we still want check_async_completion to cleanup
911 */
912 return true;
913}
914
915static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
916{
917 hva_t hva;
918 struct kvm_arch_async_pf arch;
919 int rc;
920
921 if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
922 return 0;
923 if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
924 vcpu->arch.pfault_compare)
925 return 0;
926 if (psw_extint_disabled(vcpu))
927 return 0;
928 if (kvm_cpu_has_interrupt(vcpu))
929 return 0;
930 if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul))
931 return 0;
932 if (!vcpu->arch.gmap->pfault_enabled)
933 return 0;
934
935 hva = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap);
936 if (copy_from_guest(vcpu, &arch.pfault_token, vcpu->arch.pfault_token, 8))
937 return 0;
938
939 rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
940 return rc;
941}
942
3fb4c40f 943static int vcpu_pre_run(struct kvm_vcpu *vcpu)
b0c632db 944{
3fb4c40f 945 int rc, cpuflags;
e168bf8d 946
3c038e6b
DD		 947 /*
948 * On s390 notifications for arriving pages will be delivered directly
949 * to the guest but the house keeping for completed pfaults is
950 * handled outside the worker.
951 */
952 kvm_check_async_pf_completion(vcpu);
953
5a32c1af 954 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
b0c632db
HC		 955
956 if (need_resched())
957 schedule();
958
71cde587
CB		 959 if (test_thread_flag(TIF_MCCK_PENDING))
960 s390_handle_mcck();
961
d6b6d166
CO		 962 if (!kvm_is_ucontrol(vcpu->kvm))
963 kvm_s390_deliver_pending_interrupts(vcpu);
0ff31867 964
2c70fe44
CB		 965 rc = kvm_s390_handle_requests(vcpu);
966 if (rc)
967 return rc;
968
b0c632db 969 vcpu->arch.sie_block->icptcode = 0;
3fb4c40f
TH		 970 cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
971 VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
972 trace_kvm_s390_sie_enter(vcpu, cpuflags);
2b29a9fd 973
3fb4c40f
TH		 974 return 0;
975}
976
977static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
978{
24eb3a82 979 int rc = -1;
2b29a9fd
DD		 980
981 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
982 vcpu->arch.sie_block->icptcode);
983 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
984
3fb4c40f 985 if (exit_reason >= 0) {
7c470539 986 rc = 0;
210b1607
TH		 987 } else if (kvm_is_ucontrol(vcpu->kvm)) {
988 vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
989 vcpu->run->s390_ucontrol.trans_exc_code =
990 current->thread.gmap_addr;
991 vcpu->run->s390_ucontrol.pgm_code = 0x10;
992 rc = -EREMOTE;
24eb3a82
DD		 993
994 } else if (current->thread.gmap_pfault) {
3c038e6b 995 trace_kvm_s390_major_guest_pfault(vcpu);
24eb3a82 996 current->thread.gmap_pfault = 0;
3c038e6b
DD		 997 if (kvm_arch_setup_async_pf(vcpu) ||
998 (kvm_arch_fault_in_sync(vcpu) >= 0))
24eb3a82
DD		 999 rc = 0;
1000 }
1001
1002 if (rc == -1) {
699bde3b
CB		 1003 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
1004 trace_kvm_s390_sie_fault(vcpu);
1005 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
1f0d0f09 1006 }
b0c632db 1007
5a32c1af 1008 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
3fb4c40f 1009
a76ccff6
TH		 1010 if (rc == 0) {
1011 if (kvm_is_ucontrol(vcpu->kvm))
2955c83f
CB		 1012 /* Don't exit for host interrupts. */
1013 rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0;
a76ccff6
TH		 1014 else
1015 rc = kvm_handle_sie_intercept(vcpu);
1016 }
1017
3fb4c40f
TH		 1018 return rc;
1019}
1020
b31288fa
KW		 1021bool kvm_enabled_cmma(void)
1022{
1023 if (!MACHINE_IS_LPAR)
1024 return false;
1025 /* only enable for z10 and later */
1026 if (!MACHINE_HAS_EDAT1)
1027 return false;
1028 return true;
1029}
1030
3fb4c40f
TH		 1031static int __vcpu_run(struct kvm_vcpu *vcpu)
1032{
1033 int rc, exit_reason;
1034
800c1065
TH		 1035 /*
1036 * We try to hold kvm->srcu during most of vcpu_run (except when run-
1037 * ning the guest), so that memslots (and other stuff) are protected
1038 */
1039 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
1040
a76ccff6
TH		 1041 do {
1042 rc = vcpu_pre_run(vcpu);
1043 if (rc)
1044 break;
3fb4c40f 1045
800c1065 1046 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
a76ccff6
TH		 1047 /*
1048 * As PF_VCPU will be used in fault handler, between
1049 * guest_enter and guest_exit should be no uaccess.
1050 */
1051 preempt_disable();
1052 kvm_guest_enter();
1053 preempt_enable();
1054 exit_reason = sie64a(vcpu->arch.sie_block,
1055 vcpu->run->s.regs.gprs);
1056 kvm_guest_exit();
800c1065 1057 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
a76ccff6
TH		 1058
1059 rc = vcpu_post_run(vcpu, exit_reason);
1060 } while (!signal_pending(current) && !rc);
3fb4c40f 1061
800c1065 1062 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
e168bf8d 1063 return rc;
b0c632db
HC		 1064}
1065
1066int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1067{
8f2abe6a 1068 int rc;
b0c632db
HC		 1069 sigset_t sigsaved;
1070
b0c632db
HC		 1071 if (vcpu->sigset_active)
1072 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
1073
9e6dabef 1074 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
b0c632db 1075
8f2abe6a
CB		 1076 switch (kvm_run->exit_reason) {
1077 case KVM_EXIT_S390_SIEIC:
8f2abe6a 1078 case KVM_EXIT_UNKNOWN:
9ace903d 1079 case KVM_EXIT_INTR:
8f2abe6a 1080 case KVM_EXIT_S390_RESET:
e168bf8d 1081 case KVM_EXIT_S390_UCONTROL:
fa6b7fe9 1082 case KVM_EXIT_S390_TSCH:
8f2abe6a
CB		 1083 break;
1084 default:
1085 BUG();
1086 }
1087
d7b0b5eb
CO		 1088 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
1089 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
60b413c9
CB		 1090 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
1091 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
1092 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1093 }
9eed0735
CB		 1094 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
1095 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
1096 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
1097 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1098 }
d7b0b5eb 1099
dab4079d 1100 might_fault();
a76ccff6 1101 rc = __vcpu_run(vcpu);
9ace903d 1102
b1d16c49
CE		 1103 if (signal_pending(current) && !rc) {
1104 kvm_run->exit_reason = KVM_EXIT_INTR;
8f2abe6a 1105 rc = -EINTR;
b1d16c49 1106 }
8f2abe6a 1107
b8e660b8 1108 if (rc == -EOPNOTSUPP) {
8f2abe6a
CB		 1109 /* intercept cannot be handled in-kernel, prepare kvm-run */
1110 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
1111 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
8f2abe6a
CB		 1112 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
1113 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
1114 rc = 0;
1115 }
1116
1117 if (rc == -EREMOTE) {
1118 /* intercept was handled, but userspace support is needed
1119 * kvm_run has been prepared by the handler */
1120 rc = 0;
1121 }
b0c632db 1122
d7b0b5eb
CO		 1123 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
1124 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
60b413c9 1125 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
9eed0735 1126 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
d7b0b5eb 1127
b0c632db
HC		 1128 if (vcpu->sigset_active)
1129 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1130
b0c632db 1131 vcpu->stat.exit_userspace++;
7e8e6ab4 1132 return rc;
b0c632db
HC		 1133}
1134
092670cd 1135static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
b0c632db
HC		 1136 unsigned long n, int prefix)
1137{
1138 if (prefix)
1139 return copy_to_guest(vcpu, guestdest, from, n);
1140 else
1141 return copy_to_guest_absolute(vcpu, guestdest, from, n);
1142}
1143
1144/*
1145 * store status at address
1146 * we use have two special cases:
1147 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
1148 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
1149 */
e879892c 1150int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr)
b0c632db 1151{
092670cd 1152 unsigned char archmode = 1;
b0c632db 1153 int prefix;
178bd789 1154 u64 clkcomp;
b0c632db
HC		 1155
1156 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
1157 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
1158 return -EFAULT;
1159 addr = SAVE_AREA_BASE;
1160 prefix = 0;
1161 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
1162 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
1163 return -EFAULT;
1164 addr = SAVE_AREA_BASE;
1165 prefix = 1;
1166 } else
1167 prefix = 0;
1168
f64ca217 1169 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
b0c632db
HC		 1170 vcpu->arch.guest_fpregs.fprs, 128, prefix))
1171 return -EFAULT;
1172
f64ca217 1173 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
5a32c1af 1174 vcpu->run->s.regs.gprs, 128, prefix))
b0c632db
HC		 1175 return -EFAULT;
1176
f64ca217 1177 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
b0c632db
HC		 1178 &vcpu->arch.sie_block->gpsw, 16, prefix))
1179 return -EFAULT;
1180
f64ca217 1181 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
b0c632db
HC		 1182 &vcpu->arch.sie_block->prefix, 4, prefix))
1183 return -EFAULT;
1184
1185 if (__guestcopy(vcpu,
f64ca217 1186 addr + offsetof(struct save_area, fp_ctrl_reg),
b0c632db
HC		 1187 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
1188 return -EFAULT;
1189
f64ca217 1190 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
b0c632db
HC		 1191 &vcpu->arch.sie_block->todpr, 4, prefix))
1192 return -EFAULT;
1193
f64ca217 1194 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
b0c632db
HC		 1195 &vcpu->arch.sie_block->cputm, 8, prefix))
1196 return -EFAULT;
1197
178bd789 1198 clkcomp = vcpu->arch.sie_block->ckc >> 8;
f64ca217 1199 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
178bd789 1200 &clkcomp, 8, prefix))
b0c632db
HC		 1201 return -EFAULT;
1202
f64ca217 1203 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
59674c1a 1204 &vcpu->run->s.regs.acrs, 64, prefix))
b0c632db
HC		 1205 return -EFAULT;
1206
1207 if (__guestcopy(vcpu,
f64ca217 1208 addr + offsetof(struct save_area, ctrl_regs),
b0c632db
HC		 1209 &vcpu->arch.sie_block->gcr, 128, prefix))
1210 return -EFAULT;
1211 return 0;
1212}
1213
e879892c
TH		 1214int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
1215{
1216 /*
1217 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
1218 * copying in vcpu load/put. Lets update our copies before we save
1219 * it into the save area
1220 */
1221 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1222 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
1223 save_access_regs(vcpu->run->s.regs.acrs);
1224
1225 return kvm_s390_store_status_unloaded(vcpu, addr);
1226}
1227
d6712df9
CH		 1228static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
1229 struct kvm_enable_cap *cap)
1230{
1231 int r;
1232
1233 if (cap->flags)
1234 return -EINVAL;
1235
1236 switch (cap->cap) {
fa6b7fe9
CH		 1237 case KVM_CAP_S390_CSS_SUPPORT:
1238 if (!vcpu->kvm->arch.css_support) {
1239 vcpu->kvm->arch.css_support = 1;
1240 trace_kvm_s390_enable_css(vcpu->kvm);
1241 }
1242 r = 0;
1243 break;
d6712df9
CH		 1244 default:
1245 r = -EINVAL;
1246 break;
1247 }
1248 return r;
1249}
1250
b0c632db
HC		 1251long kvm_arch_vcpu_ioctl(struct file *filp,
1252 unsigned int ioctl, unsigned long arg)
1253{
1254 struct kvm_vcpu *vcpu = filp->private_data;
1255 void __user *argp = (void __user *)arg;
800c1065 1256 int idx;
bc923cc9 1257 long r;
b0c632db 1258
93736624
AK		 1259 switch (ioctl) {
1260 case KVM_S390_INTERRUPT: {
ba5c1e9b
CO		 1261 struct kvm_s390_interrupt s390int;
1262
93736624 1263 r = -EFAULT;
ba5c1e9b 1264 if (copy_from_user(&s390int, argp, sizeof(s390int)))
93736624
AK		 1265 break;
1266 r = kvm_s390_inject_vcpu(vcpu, &s390int);
1267 break;
ba5c1e9b 1268 }
b0c632db 1269 case KVM_S390_STORE_STATUS:
800c1065 1270 idx = srcu_read_lock(&vcpu->kvm->srcu);
bc923cc9 1271 r = kvm_s390_vcpu_store_status(vcpu, arg);
800c1065 1272 srcu_read_unlock(&vcpu->kvm->srcu, idx);
bc923cc9 1273 break;
b0c632db
HC		 1274 case KVM_S390_SET_INITIAL_PSW: {
1275 psw_t psw;
1276
bc923cc9 1277 r = -EFAULT;
b0c632db 1278 if (copy_from_user(&psw, argp, sizeof(psw)))
bc923cc9
AK		 1279 break;
1280 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
1281 break;
b0c632db
HC		 1282 }
1283 case KVM_S390_INITIAL_RESET:
bc923cc9
AK		 1284 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
1285 break;
14eebd91
CO		 1286 case KVM_SET_ONE_REG:
1287 case KVM_GET_ONE_REG: {
1288 struct kvm_one_reg reg;
1289 r = -EFAULT;
1290 if (copy_from_user(&reg, argp, sizeof(reg)))
1291 break;
1292 if (ioctl == KVM_SET_ONE_REG)
1293 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
1294 else
1295 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
1296 break;
1297 }
27e0393f
CO		 1298#ifdef CONFIG_KVM_S390_UCONTROL
1299 case KVM_S390_UCAS_MAP: {
1300 struct kvm_s390_ucas_mapping ucasmap;
1301
1302 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1303 r = -EFAULT;
1304 break;
1305 }
1306
1307 if (!kvm_is_ucontrol(vcpu->kvm)) {
1308 r = -EINVAL;
1309 break;
1310 }
1311
1312 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
1313 ucasmap.vcpu_addr, ucasmap.length);
1314 break;
1315 }
1316 case KVM_S390_UCAS_UNMAP: {
1317 struct kvm_s390_ucas_mapping ucasmap;
1318
1319 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
1320 r = -EFAULT;
1321 break;
1322 }
1323
1324 if (!kvm_is_ucontrol(vcpu->kvm)) {
1325 r = -EINVAL;
1326 break;
1327 }
1328
1329 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
1330 ucasmap.length);
1331 break;
1332 }
1333#endif
ccc7910f
CO		 1334 case KVM_S390_VCPU_FAULT: {
1335 r = gmap_fault(arg, vcpu->arch.gmap);
1336 if (!IS_ERR_VALUE(r))
1337 r = 0;
1338 break;
1339 }
d6712df9
CH		 1340 case KVM_ENABLE_CAP:
1341 {
1342 struct kvm_enable_cap cap;
1343 r = -EFAULT;
1344 if (copy_from_user(&cap, argp, sizeof(cap)))
1345 break;
1346 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1347 break;
1348 }
b0c632db 1349 default:
3e6afcf1 1350 r = -ENOTTY;
b0c632db 1351 }
bc923cc9 1352 return r;
b0c632db
HC		 1353}
1354
5b1c1493
CO		 1355int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1356{
1357#ifdef CONFIG_KVM_S390_UCONTROL
1358 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
1359 && (kvm_is_ucontrol(vcpu->kvm))) {
1360 vmf->page = virt_to_page(vcpu->arch.sie_block);
1361 get_page(vmf->page);
1362 return 0;
1363 }
1364#endif
1365 return VM_FAULT_SIGBUS;
1366}
1367
5587027c 1368void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
db3fe4eb
TY		 1369 struct kvm_memory_slot *dont)
1370{
1371}
1372
5587027c
AK		 1373int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
1374 unsigned long npages)
db3fe4eb
TY		 1375{
1376 return 0;
1377}
1378
e59dbe09
TY		 1379void kvm_arch_memslots_updated(struct kvm *kvm)
1380{
1381}
1382
b0c632db 1383/* Section: memory related */
f7784b8e
MT		 1384int kvm_arch_prepare_memory_region(struct kvm *kvm,
1385 struct kvm_memory_slot *memslot,
7b6195a9
TY		 1386 struct kvm_userspace_memory_region *mem,
1387 enum kvm_mr_change change)
b0c632db 1388{
dd2887e7
NW		 1389 /* A few sanity checks. We can have memory slots which have to be
1390 located/ended at a segment boundary (1MB). The memory in userland is
1391 ok to be fragmented into various different vmas. It is okay to mmap()
1392 and munmap() stuff in this slot after doing this call at any time */
b0c632db 1393
598841ca 1394 if (mem->userspace_addr & 0xffffful)
b0c632db
HC		 1395 return -EINVAL;
1396
598841ca 1397 if (mem->memory_size & 0xffffful)
b0c632db
HC		 1398 return -EINVAL;
1399
f7784b8e
MT		 1400 return 0;
1401}
1402
1403void kvm_arch_commit_memory_region(struct kvm *kvm,
1404 struct kvm_userspace_memory_region *mem,
8482644a
TY		 1405 const struct kvm_memory_slot *old,
1406 enum kvm_mr_change change)
f7784b8e 1407{
f7850c92 1408 int rc;
f7784b8e 1409
2cef4deb
CB		 1410 /* If the basics of the memslot do not change, we do not want
1411 * to update the gmap. Every update causes several unnecessary
1412 * segment translation exceptions. This is usually handled just
1413 * fine by the normal fault handler + gmap, but it will also
1414 * cause faults on the prefix page of running guest CPUs.
1415 */
1416 if (old->userspace_addr == mem->userspace_addr &&
1417 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1418 old->npages * PAGE_SIZE == mem->memory_size)
1419 return;
598841ca
CO		 1420
1421 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1422 mem->guest_phys_addr, mem->memory_size);
1423 if (rc)
f7850c92 1424 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
598841ca 1425 return;
b0c632db
HC		 1426}
1427
2df72e9b
MT		 1428void kvm_arch_flush_shadow_all(struct kvm *kvm)
1429{
1430}
1431
1432void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1433 struct kvm_memory_slot *slot)
34d4cb8f
MT		 1434{
1435}
1436
b0c632db
HC		 1437static int __init kvm_s390_init(void)
1438{
ef50f7ac 1439 int ret;
0ee75bea 1440 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
ef50f7ac
CB		 1441 if (ret)
1442 return ret;
1443
1444 /*
1445 * guests can ask for up to 255+1 double words, we need a full page
25985edc 1446 * to hold the maximum amount of facilities. On the other hand, we
ef50f7ac
CB		 1447 * only set facilities that are known to work in KVM.
1448 */
78c4b59f
MM		 1449 vfacilities = (unsigned long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1450 if (!vfacilities) {
ef50f7ac
CB		 1451 kvm_exit();
1452 return -ENOMEM;
1453 }
78c4b59f 1454 memcpy(vfacilities, S390_lowcore.stfle_fac_list, 16);
d208c79d 1455 vfacilities[0] &= 0xff82fff3f4fc2000UL;
7feb6bb8 1456 vfacilities[1] &= 0x005c000000000000UL;
ef50f7ac 1457 return 0;
b0c632db
HC		 1458}
1459
1460static void __exit kvm_s390_exit(void)
1461{
78c4b59f 1462 free_page((unsigned long) vfacilities);
b0c632db
HC		 1463 kvm_exit();
1464}
1465
1466module_init(kvm_s390_init);
1467module_exit(kvm_s390_exit);
566af940
CH		 1468
1469/*
1470 * Enable autoloading of the kvm module.
1471 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
1472 * since x86 takes a different approach.
1473 */
1474#include <linux/miscdevice.h>
1475MODULE_ALIAS_MISCDEV(KVM_MINOR);
1476MODULE_ALIAS("devname:kvm");
Ubuntu Artful kernel mirror