]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - arch/s390/kvm/kvm-s390.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
KVM: s390/cpacf: Fix kernel bug under z/VM
[mirror_ubuntu-hirsute-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>
a374e892 25#include <linux/random.h>
b0c632db 26#include <linux/slab.h>
ba5c1e9b 27#include <linux/timer.h>
cbb870c8 28#include <asm/asm-offsets.h>
b0c632db
HC		 29#include <asm/lowcore.h>
30#include <asm/pgtable.h>
f5daba1d 31#include <asm/nmi.h>
a0616cde 32#include <asm/switch_to.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) },
f7819512 53 { "halt_successful_poll", VCPU_STAT(halt_successful_poll) },
ce2e4f0b 54 { "halt_wakeup", VCPU_STAT(halt_wakeup) },
f5e10b09 55 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
ba5c1e9b 56 { "instruction_lctl", VCPU_STAT(instruction_lctl) },
aba07508
DH		 57 { "instruction_stctl", VCPU_STAT(instruction_stctl) },
58 { "instruction_stctg", VCPU_STAT(instruction_stctg) },
ba5c1e9b 59 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
7697e71f 60 { "deliver_external_call", VCPU_STAT(deliver_external_call) },
ba5c1e9b
CO		 61 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
62 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
63 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
64 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
65 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
66 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
67 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
69d0d3a3 68 { "instruction_pfmf", VCPU_STAT(instruction_pfmf) },
453423dc
CB		 69 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
70 { "instruction_spx", VCPU_STAT(instruction_spx) },
71 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
72 { "instruction_stap", VCPU_STAT(instruction_stap) },
73 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
8a242234 74 { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) },
453423dc
CB		 75 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
76 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
b31288fa 77 { "instruction_essa", VCPU_STAT(instruction_essa) },
453423dc
CB		 78 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
79 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
bb25b9ba 80 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
5288fbf0 81 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
bd59d3a4 82 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
7697e71f 83 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
5288fbf0 84 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
42cb0c9f
DH		 85 { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) },
86 { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) },
5288fbf0 87 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
42cb0c9f
DH		 88 { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) },
89 { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) },
5288fbf0
CB		 90 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
91 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
92 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
42cb0c9f
DH		 93 { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) },
94 { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) },
95 { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) },
388186bc 96 { "diagnose_10", VCPU_STAT(diagnose_10) },
e28acfea 97 { "diagnose_44", VCPU_STAT(diagnose_44) },
41628d33 98 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
b0c632db
HC		 99 { NULL }
100};
101
9d8d5786
MM		 102/* upper facilities limit for kvm */
103unsigned long kvm_s390_fac_list_mask[] = {
104 0xff82fffbf4fc2000UL,
105 0x005c000000000000UL,
106};
b0c632db 107
9d8d5786 108unsigned long kvm_s390_fac_list_mask_size(void)
78c4b59f 109{
9d8d5786
MM		 110 BUILD_BUG_ON(ARRAY_SIZE(kvm_s390_fac_list_mask) > S390_ARCH_FAC_MASK_SIZE_U64);
111 return ARRAY_SIZE(kvm_s390_fac_list_mask);
78c4b59f
MM		 112}
113
9d8d5786
MM		 114static struct gmap_notifier gmap_notifier;
115
b0c632db 116/* Section: not file related */
13a34e06 117int kvm_arch_hardware_enable(void)
b0c632db
HC		 118{
119 /* every s390 is virtualization enabled ;-) */
10474ae8 120 return 0;
b0c632db
HC		 121}
122
2c70fe44
CB		 123static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
124
b0c632db
HC		 125int kvm_arch_hardware_setup(void)
126{
2c70fe44
CB		 127 gmap_notifier.notifier_call = kvm_gmap_notifier;
128 gmap_register_ipte_notifier(&gmap_notifier);
b0c632db
HC		 129 return 0;
130}
131
132void kvm_arch_hardware_unsetup(void)
133{
2c70fe44 134 gmap_unregister_ipte_notifier(&gmap_notifier);
b0c632db
HC		 135}
136
b0c632db
HC		 137int kvm_arch_init(void *opaque)
138{
84877d93
CH		 139 /* Register floating interrupt controller interface. */
140 return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC);
b0c632db
HC		 141}
142
b0c632db
HC		 143/* Section: device related */
144long kvm_arch_dev_ioctl(struct file *filp,
145 unsigned int ioctl, unsigned long arg)
146{
147 if (ioctl == KVM_S390_ENABLE_SIE)
148 return s390_enable_sie();
149 return -EINVAL;
150}
151
784aa3d7 152int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
b0c632db 153{
d7b0b5eb
CO		 154 int r;
155
2bd0ac4e 156 switch (ext) {
d7b0b5eb 157 case KVM_CAP_S390_PSW:
b6cf8788 158 case KVM_CAP_S390_GMAP:
52e16b18 159 case KVM_CAP_SYNC_MMU:
1efd0f59
CO		 160#ifdef CONFIG_KVM_S390_UCONTROL
161 case KVM_CAP_S390_UCONTROL:
162#endif
3c038e6b 163 case KVM_CAP_ASYNC_PF:
60b413c9 164 case KVM_CAP_SYNC_REGS:
14eebd91 165 case KVM_CAP_ONE_REG:
d6712df9 166 case KVM_CAP_ENABLE_CAP:
fa6b7fe9 167 case KVM_CAP_S390_CSS_SUPPORT:
ebc32262 168 case KVM_CAP_IRQFD:
10ccaa1e 169 case KVM_CAP_IOEVENTFD:
c05c4186 170 case KVM_CAP_DEVICE_CTRL:
d938dc55 171 case KVM_CAP_ENABLE_CAP_VM:
78599d90 172 case KVM_CAP_S390_IRQCHIP:
f2061656 173 case KVM_CAP_VM_ATTRIBUTES:
6352e4d2 174 case KVM_CAP_MP_STATE:
2444b352 175 case KVM_CAP_S390_USER_SIGP:
d7b0b5eb
CO		 176 r = 1;
177 break;
e726b1bd
CB		 178 case KVM_CAP_NR_VCPUS:
179 case KVM_CAP_MAX_VCPUS:
180 r = KVM_MAX_VCPUS;
181 break;
e1e2e605
NW		 182 case KVM_CAP_NR_MEMSLOTS:
183 r = KVM_USER_MEM_SLOTS;
184 break;
1526bf9c 185 case KVM_CAP_S390_COW:
abf09bed 186 r = MACHINE_HAS_ESOP;
1526bf9c 187 break;
2bd0ac4e 188 default:
d7b0b5eb 189 r = 0;
2bd0ac4e 190 }
d7b0b5eb 191 return r;
b0c632db
HC		 192}
193
15f36ebd
JH		 194static void kvm_s390_sync_dirty_log(struct kvm *kvm,
195 struct kvm_memory_slot *memslot)
196{
197 gfn_t cur_gfn, last_gfn;
198 unsigned long address;
199 struct gmap *gmap = kvm->arch.gmap;
200
201 down_read(&gmap->mm->mmap_sem);
202 /* Loop over all guest pages */
203 last_gfn = memslot->base_gfn + memslot->npages;
204 for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) {
205 address = gfn_to_hva_memslot(memslot, cur_gfn);
206
207 if (gmap_test_and_clear_dirty(address, gmap))
208 mark_page_dirty(kvm, cur_gfn);
209 }
210 up_read(&gmap->mm->mmap_sem);
211}
212
b0c632db
HC		 213/* Section: vm related */
214/*
215 * Get (and clear) the dirty memory log for a memory slot.
216 */
217int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
218 struct kvm_dirty_log *log)
219{
15f36ebd
JH		 220 int r;
221 unsigned long n;
222 struct kvm_memory_slot *memslot;
223 int is_dirty = 0;
224
225 mutex_lock(&kvm->slots_lock);
226
227 r = -EINVAL;
228 if (log->slot >= KVM_USER_MEM_SLOTS)
229 goto out;
230
231 memslot = id_to_memslot(kvm->memslots, log->slot);
232 r = -ENOENT;
233 if (!memslot->dirty_bitmap)
234 goto out;
235
236 kvm_s390_sync_dirty_log(kvm, memslot);
237 r = kvm_get_dirty_log(kvm, log, &is_dirty);
238 if (r)
239 goto out;
240
241 /* Clear the dirty log */
242 if (is_dirty) {
243 n = kvm_dirty_bitmap_bytes(memslot);
244 memset(memslot->dirty_bitmap, 0, n);
245 }
246 r = 0;
247out:
248 mutex_unlock(&kvm->slots_lock);
249 return r;
b0c632db
HC		 250}
251
d938dc55
CH		 252static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
253{
254 int r;
255
256 if (cap->flags)
257 return -EINVAL;
258
259 switch (cap->cap) {
84223598
CH		 260 case KVM_CAP_S390_IRQCHIP:
261 kvm->arch.use_irqchip = 1;
262 r = 0;
263 break;
2444b352
DH		 264 case KVM_CAP_S390_USER_SIGP:
265 kvm->arch.user_sigp = 1;
266 r = 0;
267 break;
d938dc55
CH		 268 default:
269 r = -EINVAL;
270 break;
271 }
272 return r;
273}
274
8c0a7ce6
DD		 275static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
276{
277 int ret;
278
279 switch (attr->attr) {
280 case KVM_S390_VM_MEM_LIMIT_SIZE:
281 ret = 0;
282 if (put_user(kvm->arch.gmap->asce_end, (u64 __user *)attr->addr))
283 ret = -EFAULT;
284 break;
285 default:
286 ret = -ENXIO;
287 break;
288 }
289 return ret;
290}
291
292static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
4f718eab
DD		 293{
294 int ret;
295 unsigned int idx;
296 switch (attr->attr) {
297 case KVM_S390_VM_MEM_ENABLE_CMMA:
298 ret = -EBUSY;
299 mutex_lock(&kvm->lock);
300 if (atomic_read(&kvm->online_vcpus) == 0) {
301 kvm->arch.use_cmma = 1;
302 ret = 0;
303 }
304 mutex_unlock(&kvm->lock);
305 break;
306 case KVM_S390_VM_MEM_CLR_CMMA:
307 mutex_lock(&kvm->lock);
308 idx = srcu_read_lock(&kvm->srcu);
a13cff31 309 s390_reset_cmma(kvm->arch.gmap->mm);
4f718eab
DD		 310 srcu_read_unlock(&kvm->srcu, idx);
311 mutex_unlock(&kvm->lock);
312 ret = 0;
313 break;
8c0a7ce6
DD		 314 case KVM_S390_VM_MEM_LIMIT_SIZE: {
315 unsigned long new_limit;
316
317 if (kvm_is_ucontrol(kvm))
318 return -EINVAL;
319
320 if (get_user(new_limit, (u64 __user *)attr->addr))
321 return -EFAULT;
322
323 if (new_limit > kvm->arch.gmap->asce_end)
324 return -E2BIG;
325
326 ret = -EBUSY;
327 mutex_lock(&kvm->lock);
328 if (atomic_read(&kvm->online_vcpus) == 0) {
329 /* gmap_alloc will round the limit up */
330 struct gmap *new = gmap_alloc(current->mm, new_limit);
331
332 if (!new) {
333 ret = -ENOMEM;
334 } else {
335 gmap_free(kvm->arch.gmap);
336 new->private = kvm;
337 kvm->arch.gmap = new;
338 ret = 0;
339 }
340 }
341 mutex_unlock(&kvm->lock);
342 break;
343 }
4f718eab
DD		 344 default:
345 ret = -ENXIO;
346 break;
347 }
348 return ret;
349}
350
a374e892
TK		 351static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu);
352
353static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr)
354{
355 struct kvm_vcpu *vcpu;
356 int i;
357
9d8d5786 358 if (!test_kvm_facility(kvm, 76))
a374e892
TK		 359 return -EINVAL;
360
361 mutex_lock(&kvm->lock);
362 switch (attr->attr) {
363 case KVM_S390_VM_CRYPTO_ENABLE_AES_KW:
364 get_random_bytes(
365 kvm->arch.crypto.crycb->aes_wrapping_key_mask,
366 sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
367 kvm->arch.crypto.aes_kw = 1;
368 break;
369 case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW:
370 get_random_bytes(
371 kvm->arch.crypto.crycb->dea_wrapping_key_mask,
372 sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
373 kvm->arch.crypto.dea_kw = 1;
374 break;
375 case KVM_S390_VM_CRYPTO_DISABLE_AES_KW:
376 kvm->arch.crypto.aes_kw = 0;
377 memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0,
378 sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
379 break;
380 case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW:
381 kvm->arch.crypto.dea_kw = 0;
382 memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0,
383 sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
384 break;
385 default:
386 mutex_unlock(&kvm->lock);
387 return -ENXIO;
388 }
389
390 kvm_for_each_vcpu(i, vcpu, kvm) {
391 kvm_s390_vcpu_crypto_setup(vcpu);
392 exit_sie(vcpu);
393 }
394 mutex_unlock(&kvm->lock);
395 return 0;
396}
397
72f25020
JH		 398static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
399{
400 u8 gtod_high;
401
402 if (copy_from_user(&gtod_high, (void __user *)attr->addr,
403 sizeof(gtod_high)))
404 return -EFAULT;
405
406 if (gtod_high != 0)
407 return -EINVAL;
408
409 return 0;
410}
411
412static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
413{
414 struct kvm_vcpu *cur_vcpu;
415 unsigned int vcpu_idx;
416 u64 host_tod, gtod;
417 int r;
418
419 if (copy_from_user(&gtod, (void __user *)attr->addr, sizeof(gtod)))
420 return -EFAULT;
421
422 r = store_tod_clock(&host_tod);
423 if (r)
424 return r;
425
426 mutex_lock(&kvm->lock);
427 kvm->arch.epoch = gtod - host_tod;
428 kvm_for_each_vcpu(vcpu_idx, cur_vcpu, kvm) {
429 cur_vcpu->arch.sie_block->epoch = kvm->arch.epoch;
430 exit_sie(cur_vcpu);
431 }
432 mutex_unlock(&kvm->lock);
433 return 0;
434}
435
436static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr)
437{
438 int ret;
439
440 if (attr->flags)
441 return -EINVAL;
442
443 switch (attr->attr) {
444 case KVM_S390_VM_TOD_HIGH:
445 ret = kvm_s390_set_tod_high(kvm, attr);
446 break;
447 case KVM_S390_VM_TOD_LOW:
448 ret = kvm_s390_set_tod_low(kvm, attr);
449 break;
450 default:
451 ret = -ENXIO;
452 break;
453 }
454 return ret;
455}
456
457static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
458{
459 u8 gtod_high = 0;
460
461 if (copy_to_user((void __user *)attr->addr, &gtod_high,
462 sizeof(gtod_high)))
463 return -EFAULT;
464
465 return 0;
466}
467
468static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
469{
470 u64 host_tod, gtod;
471 int r;
472
473 r = store_tod_clock(&host_tod);
474 if (r)
475 return r;
476
477 gtod = host_tod + kvm->arch.epoch;
478 if (copy_to_user((void __user *)attr->addr, &gtod, sizeof(gtod)))
479 return -EFAULT;
480
481 return 0;
482}
483
484static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr)
485{
486 int ret;
487
488 if (attr->flags)
489 return -EINVAL;
490
491 switch (attr->attr) {
492 case KVM_S390_VM_TOD_HIGH:
493 ret = kvm_s390_get_tod_high(kvm, attr);
494 break;
495 case KVM_S390_VM_TOD_LOW:
496 ret = kvm_s390_get_tod_low(kvm, attr);
497 break;
498 default:
499 ret = -ENXIO;
500 break;
501 }
502 return ret;
503}
504
658b6eda
MM		 505static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr)
506{
507 struct kvm_s390_vm_cpu_processor *proc;
508 int ret = 0;
509
510 mutex_lock(&kvm->lock);
511 if (atomic_read(&kvm->online_vcpus)) {
512 ret = -EBUSY;
513 goto out;
514 }
515 proc = kzalloc(sizeof(*proc), GFP_KERNEL);
516 if (!proc) {
517 ret = -ENOMEM;
518 goto out;
519 }
520 if (!copy_from_user(proc, (void __user *)attr->addr,
521 sizeof(*proc))) {
522 memcpy(&kvm->arch.model.cpu_id, &proc->cpuid,
523 sizeof(struct cpuid));
524 kvm->arch.model.ibc = proc->ibc;
525 memcpy(kvm->arch.model.fac->kvm, proc->fac_list,
526 S390_ARCH_FAC_LIST_SIZE_BYTE);
527 } else
528 ret = -EFAULT;
529 kfree(proc);
530out:
531 mutex_unlock(&kvm->lock);
532 return ret;
533}
534
535static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr)
536{
537 int ret = -ENXIO;
538
539 switch (attr->attr) {
540 case KVM_S390_VM_CPU_PROCESSOR:
541 ret = kvm_s390_set_processor(kvm, attr);
542 break;
543 }
544 return ret;
545}
546
547static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr)
548{
549 struct kvm_s390_vm_cpu_processor *proc;
550 int ret = 0;
551
552 proc = kzalloc(sizeof(*proc), GFP_KERNEL);
553 if (!proc) {
554 ret = -ENOMEM;
555 goto out;
556 }
557 memcpy(&proc->cpuid, &kvm->arch.model.cpu_id, sizeof(struct cpuid));
558 proc->ibc = kvm->arch.model.ibc;
559 memcpy(&proc->fac_list, kvm->arch.model.fac->kvm, S390_ARCH_FAC_LIST_SIZE_BYTE);
560 if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc)))
561 ret = -EFAULT;
562 kfree(proc);
563out:
564 return ret;
565}
566
567static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr)
568{
569 struct kvm_s390_vm_cpu_machine *mach;
570 int ret = 0;
571
572 mach = kzalloc(sizeof(*mach), GFP_KERNEL);
573 if (!mach) {
574 ret = -ENOMEM;
575 goto out;
576 }
577 get_cpu_id((struct cpuid *) &mach->cpuid);
578 mach->ibc = sclp_get_ibc();
579 memcpy(&mach->fac_mask, kvm_s390_fac_list_mask,
580 kvm_s390_fac_list_mask_size() * sizeof(u64));
581 memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list,
582 S390_ARCH_FAC_LIST_SIZE_U64);
583 if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach)))
584 ret = -EFAULT;
585 kfree(mach);
586out:
587 return ret;
588}
589
590static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr)
591{
592 int ret = -ENXIO;
593
594 switch (attr->attr) {
595 case KVM_S390_VM_CPU_PROCESSOR:
596 ret = kvm_s390_get_processor(kvm, attr);
597 break;
598 case KVM_S390_VM_CPU_MACHINE:
599 ret = kvm_s390_get_machine(kvm, attr);
600 break;
601 }
602 return ret;
603}
604
f2061656
DD		 605static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr)
606{
607 int ret;
608
609 switch (attr->group) {
4f718eab 610 case KVM_S390_VM_MEM_CTRL:
8c0a7ce6 611 ret = kvm_s390_set_mem_control(kvm, attr);
4f718eab 612 break;
72f25020
JH		 613 case KVM_S390_VM_TOD:
614 ret = kvm_s390_set_tod(kvm, attr);
615 break;
658b6eda
MM		 616 case KVM_S390_VM_CPU_MODEL:
617 ret = kvm_s390_set_cpu_model(kvm, attr);
618 break;
a374e892
TK		 619 case KVM_S390_VM_CRYPTO:
620 ret = kvm_s390_vm_set_crypto(kvm, attr);
621 break;
f2061656
DD		 622 default:
623 ret = -ENXIO;
624 break;
625 }
626
627 return ret;
628}
629
630static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr)
631{
8c0a7ce6
DD		 632 int ret;
633
634 switch (attr->group) {
635 case KVM_S390_VM_MEM_CTRL:
636 ret = kvm_s390_get_mem_control(kvm, attr);
637 break;
72f25020
JH		 638 case KVM_S390_VM_TOD:
639 ret = kvm_s390_get_tod(kvm, attr);
640 break;
658b6eda
MM		 641 case KVM_S390_VM_CPU_MODEL:
642 ret = kvm_s390_get_cpu_model(kvm, attr);
643 break;
8c0a7ce6
DD		 644 default:
645 ret = -ENXIO;
646 break;
647 }
648
649 return ret;
f2061656
DD		 650}
651
652static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr)
653{
654 int ret;
655
656 switch (attr->group) {
4f718eab
DD		 657 case KVM_S390_VM_MEM_CTRL:
658 switch (attr->attr) {
659 case KVM_S390_VM_MEM_ENABLE_CMMA:
660 case KVM_S390_VM_MEM_CLR_CMMA:
8c0a7ce6 661 case KVM_S390_VM_MEM_LIMIT_SIZE:
4f718eab
DD		 662 ret = 0;
663 break;
664 default:
665 ret = -ENXIO;
666 break;
667 }
668 break;
72f25020
JH		 669 case KVM_S390_VM_TOD:
670 switch (attr->attr) {
671 case KVM_S390_VM_TOD_LOW:
672 case KVM_S390_VM_TOD_HIGH:
673 ret = 0;
674 break;
675 default:
676 ret = -ENXIO;
677 break;
678 }
679 break;
658b6eda
MM		 680 case KVM_S390_VM_CPU_MODEL:
681 switch (attr->attr) {
682 case KVM_S390_VM_CPU_PROCESSOR:
683 case KVM_S390_VM_CPU_MACHINE:
684 ret = 0;
685 break;
686 default:
687 ret = -ENXIO;
688 break;
689 }
690 break;
a374e892
TK		 691 case KVM_S390_VM_CRYPTO:
692 switch (attr->attr) {
693 case KVM_S390_VM_CRYPTO_ENABLE_AES_KW:
694 case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW:
695 case KVM_S390_VM_CRYPTO_DISABLE_AES_KW:
696 case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW:
697 ret = 0;
698 break;
699 default:
700 ret = -ENXIO;
701 break;
702 }
703 break;
f2061656
DD		 704 default:
705 ret = -ENXIO;
706 break;
707 }
708
709 return ret;
710}
711
b0c632db
HC		 712long kvm_arch_vm_ioctl(struct file *filp,
713 unsigned int ioctl, unsigned long arg)
714{
715 struct kvm *kvm = filp->private_data;
716 void __user *argp = (void __user *)arg;
f2061656 717 struct kvm_device_attr attr;
b0c632db
HC		 718 int r;
719
720 switch (ioctl) {
ba5c1e9b
CO		 721 case KVM_S390_INTERRUPT: {
722 struct kvm_s390_interrupt s390int;
723
724 r = -EFAULT;
725 if (copy_from_user(&s390int, argp, sizeof(s390int)))
726 break;
727 r = kvm_s390_inject_vm(kvm, &s390int);
728 break;
729 }
d938dc55
CH		 730 case KVM_ENABLE_CAP: {
731 struct kvm_enable_cap cap;
732 r = -EFAULT;
733 if (copy_from_user(&cap, argp, sizeof(cap)))
734 break;
735 r = kvm_vm_ioctl_enable_cap(kvm, &cap);
736 break;
737 }
84223598
CH		 738 case KVM_CREATE_IRQCHIP: {
739 struct kvm_irq_routing_entry routing;
740
741 r = -EINVAL;
742 if (kvm->arch.use_irqchip) {
743 /* Set up dummy routing. */
744 memset(&routing, 0, sizeof(routing));
745 kvm_set_irq_routing(kvm, &routing, 0, 0);
746 r = 0;
747 }
748 break;
749 }
f2061656
DD		 750 case KVM_SET_DEVICE_ATTR: {
751 r = -EFAULT;
752 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
753 break;
754 r = kvm_s390_vm_set_attr(kvm, &attr);
755 break;
756 }
757 case KVM_GET_DEVICE_ATTR: {
758 r = -EFAULT;
759 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
760 break;
761 r = kvm_s390_vm_get_attr(kvm, &attr);
762 break;
763 }
764 case KVM_HAS_DEVICE_ATTR: {
765 r = -EFAULT;
766 if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
767 break;
768 r = kvm_s390_vm_has_attr(kvm, &attr);
769 break;
770 }
b0c632db 771 default:
367e1319 772 r = -ENOTTY;
b0c632db
HC		 773 }
774
775 return r;
776}
777
45c9b47c
TK		 778static int kvm_s390_query_ap_config(u8 *config)
779{
780 u32 fcn_code = 0x04000000UL;
86044c8c 781 u32 cc = 0;
45c9b47c 782
86044c8c 783 memset(config, 0, 128);
45c9b47c
TK		 784 asm volatile(
785 "lgr 0,%1\n"
786 "lgr 2,%2\n"
787 ".long 0xb2af0000\n" /* PQAP(QCI) */
86044c8c 788 "0: ipm %0\n"
45c9b47c 789 "srl %0,28\n"
86044c8c
CB		 790 "1:\n"
791 EX_TABLE(0b, 1b)
792 : "+r" (cc)
45c9b47c
TK		 793 : "r" (fcn_code), "r" (config)
794 : "cc", "0", "2", "memory"
795 );
796
797 return cc;
798}
799
800static int kvm_s390_apxa_installed(void)
801{
802 u8 config[128];
803 int cc;
804
805 if (test_facility(2) && test_facility(12)) {
806 cc = kvm_s390_query_ap_config(config);
807
808 if (cc)
809 pr_err("PQAP(QCI) failed with cc=%d", cc);
810 else
811 return config[0] & 0x40;
812 }
813
814 return 0;
815}
816
817static void kvm_s390_set_crycb_format(struct kvm *kvm)
818{
819 kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb;
820
821 if (kvm_s390_apxa_installed())
822 kvm->arch.crypto.crycbd |= CRYCB_FORMAT2;
823 else
824 kvm->arch.crypto.crycbd |= CRYCB_FORMAT1;
825}
826
9d8d5786
MM		 827static void kvm_s390_get_cpu_id(struct cpuid *cpu_id)
828{
829 get_cpu_id(cpu_id);
830 cpu_id->version = 0xff;
831}
832
5102ee87
TK		 833static int kvm_s390_crypto_init(struct kvm *kvm)
834{
9d8d5786 835 if (!test_kvm_facility(kvm, 76))
5102ee87
TK		 836 return 0;
837
838 kvm->arch.crypto.crycb = kzalloc(sizeof(*kvm->arch.crypto.crycb),
839 GFP_KERNEL | GFP_DMA);
840 if (!kvm->arch.crypto.crycb)
841 return -ENOMEM;
842
45c9b47c 843 kvm_s390_set_crycb_format(kvm);
5102ee87 844
ed6f76b4
TK		 845 /* Enable AES/DEA protected key functions by default */
846 kvm->arch.crypto.aes_kw = 1;
847 kvm->arch.crypto.dea_kw = 1;
848 get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask,
849 sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
850 get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask,
851 sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
a374e892 852
5102ee87
TK		 853 return 0;
854}
855
e08b9637 856int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
b0c632db 857{
9d8d5786 858 int i, rc;
b0c632db 859 char debug_name[16];
f6c137ff 860 static unsigned long sca_offset;
b0c632db 861
e08b9637
CO		 862 rc = -EINVAL;
863#ifdef CONFIG_KVM_S390_UCONTROL
864 if (type & ~KVM_VM_S390_UCONTROL)
865 goto out_err;
866 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
867 goto out_err;
868#else
869 if (type)
870 goto out_err;
871#endif
872
b0c632db
HC		 873 rc = s390_enable_sie();
874 if (rc)
d89f5eff 875 goto out_err;
b0c632db 876
b290411a
CO		 877 rc = -ENOMEM;
878
b0c632db
HC		 879 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
880 if (!kvm->arch.sca)
d89f5eff 881 goto out_err;
f6c137ff
CB		 882 spin_lock(&kvm_lock);
883 sca_offset = (sca_offset + 16) & 0x7f0;
884 kvm->arch.sca = (struct sca_block *) ((char *) kvm->arch.sca + sca_offset);
885 spin_unlock(&kvm_lock);
b0c632db
HC		 886
887 sprintf(debug_name, "kvm-%u", current->pid);
888
889 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
890 if (!kvm->arch.dbf)
891 goto out_nodbf;
892
9d8d5786
MM		 893 /*
894 * The architectural maximum amount of facilities is 16 kbit. To store
895 * this amount, 2 kbyte of memory is required. Thus we need a full
896 * page to hold the active copy (arch.model.fac->sie) and the current
897 * facilities set (arch.model.fac->kvm). Its address size has to be
898 * 31 bits and word aligned.
899 */
900 kvm->arch.model.fac =
901 (struct s390_model_fac *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
902 if (!kvm->arch.model.fac)
903 goto out_nofac;
904
905 memcpy(kvm->arch.model.fac->kvm, S390_lowcore.stfle_fac_list,
906 S390_ARCH_FAC_LIST_SIZE_U64);
907
658b6eda
MM		 908 /*
909 * If this KVM host runs *not* in a LPAR, relax the facility bits
910 * of the kvm facility mask by all missing facilities. This will allow
911 * to determine the right CPU model by means of the remaining facilities.
912 * Live guest migration must prohibit the migration of KVMs running in
913 * a LPAR to non LPAR hosts.
914 */
915 if (!MACHINE_IS_LPAR)
916 for (i = 0; i < kvm_s390_fac_list_mask_size(); i++)
917 kvm_s390_fac_list_mask[i] &= kvm->arch.model.fac->kvm[i];
918
9d8d5786
MM		 919 /*
920 * Apply the kvm facility mask to limit the kvm supported/tolerated
921 * facility list.
922 */
923 for (i = 0; i < S390_ARCH_FAC_LIST_SIZE_U64; i++) {
924 if (i < kvm_s390_fac_list_mask_size())
925 kvm->arch.model.fac->kvm[i] &= kvm_s390_fac_list_mask[i];
926 else
927 kvm->arch.model.fac->kvm[i] = 0UL;
928 }
929
930 kvm_s390_get_cpu_id(&kvm->arch.model.cpu_id);
658b6eda 931 kvm->arch.model.ibc = sclp_get_ibc() & 0x0fff;
9d8d5786 932
5102ee87
TK		 933 if (kvm_s390_crypto_init(kvm) < 0)
934 goto out_crypto;
935
ba5c1e9b
CO		 936 spin_lock_init(&kvm->arch.float_int.lock);
937 INIT_LIST_HEAD(&kvm->arch.float_int.list);
8a242234 938 init_waitqueue_head(&kvm->arch.ipte_wq);
a6b7e459 939 mutex_init(&kvm->arch.ipte_mutex);
ba5c1e9b 940
b0c632db
HC		 941 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
942 VM_EVENT(kvm, 3, "%s", "vm created");
943
e08b9637
CO		 944 if (type & KVM_VM_S390_UCONTROL) {
945 kvm->arch.gmap = NULL;
946 } else {
0349985a 947 kvm->arch.gmap = gmap_alloc(current->mm, (1UL << 44) - 1);
e08b9637
CO		 948 if (!kvm->arch.gmap)
949 goto out_nogmap;
2c70fe44 950 kvm->arch.gmap->private = kvm;
24eb3a82 951 kvm->arch.gmap->pfault_enabled = 0;
e08b9637 952 }
fa6b7fe9
CH		 953
954 kvm->arch.css_support = 0;
84223598 955 kvm->arch.use_irqchip = 0;
72f25020 956 kvm->arch.epoch = 0;
fa6b7fe9 957
8ad35755
DH		 958 spin_lock_init(&kvm->arch.start_stop_lock);
959
d89f5eff 960 return 0;
598841ca 961out_nogmap:
5102ee87
TK		 962 kfree(kvm->arch.crypto.crycb);
963out_crypto:
9d8d5786
MM		 964 free_page((unsigned long)kvm->arch.model.fac);
965out_nofac:
598841ca 966 debug_unregister(kvm->arch.dbf);
b0c632db
HC		 967out_nodbf:
968 free_page((unsigned long)(kvm->arch.sca));
d89f5eff
JK		 969out_err:
970 return rc;
b0c632db
HC		 971}
972
d329c035
CB		 973void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
974{
975 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
ade38c31 976 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
67335e63 977 kvm_s390_clear_local_irqs(vcpu);
3c038e6b 978 kvm_clear_async_pf_completion_queue(vcpu);
58f9460b
CO		 979 if (!kvm_is_ucontrol(vcpu->kvm)) {
980 clear_bit(63 - vcpu->vcpu_id,
981 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
982 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
983 (__u64) vcpu->arch.sie_block)
984 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
985 }
abf4a71e 986 smp_mb();
27e0393f
CO		 987
988 if (kvm_is_ucontrol(vcpu->kvm))
989 gmap_free(vcpu->arch.gmap);
990
b31605c1
DD		 991 if (kvm_s390_cmma_enabled(vcpu->kvm))
992 kvm_s390_vcpu_unsetup_cmma(vcpu);
d329c035 993 free_page((unsigned long)(vcpu->arch.sie_block));
b31288fa 994
6692cef3 995 kvm_vcpu_uninit(vcpu);
b110feaf 996 kmem_cache_free(kvm_vcpu_cache, vcpu);
d329c035
CB		 997}
998
999static void kvm_free_vcpus(struct kvm *kvm)
1000{
1001 unsigned int i;
988a2cae 1002 struct kvm_vcpu *vcpu;
d329c035 1003
988a2cae
GN		 1004 kvm_for_each_vcpu(i, vcpu, kvm)
1005 kvm_arch_vcpu_destroy(vcpu);
1006
1007 mutex_lock(&kvm->lock);
1008 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
1009 kvm->vcpus[i] = NULL;
1010
1011 atomic_set(&kvm->online_vcpus, 0);
1012 mutex_unlock(&kvm->lock);
d329c035
CB		 1013}
1014
b0c632db
HC		 1015void kvm_arch_destroy_vm(struct kvm *kvm)
1016{
d329c035 1017 kvm_free_vcpus(kvm);
9d8d5786 1018 free_page((unsigned long)kvm->arch.model.fac);
b0c632db 1019 free_page((unsigned long)(kvm->arch.sca));
d329c035 1020 debug_unregister(kvm->arch.dbf);
5102ee87 1021 kfree(kvm->arch.crypto.crycb);
27e0393f
CO		 1022 if (!kvm_is_ucontrol(kvm))
1023 gmap_free(kvm->arch.gmap);
841b91c5 1024 kvm_s390_destroy_adapters(kvm);
67335e63 1025 kvm_s390_clear_float_irqs(kvm);
b0c632db
HC		 1026}
1027
1028/* Section: vcpu related */
dafd032a
DD		 1029static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu)
1030{
1031 vcpu->arch.gmap = gmap_alloc(current->mm, -1UL);
1032 if (!vcpu->arch.gmap)
1033 return -ENOMEM;
1034 vcpu->arch.gmap->private = vcpu->kvm;
1035
1036 return 0;
1037}
1038
b0c632db
HC		 1039int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
1040{
3c038e6b
DD		 1041 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
1042 kvm_clear_async_pf_completion_queue(vcpu);
59674c1a
CB		 1043 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
1044 KVM_SYNC_GPRS |
9eed0735 1045 KVM_SYNC_ACRS |
b028ee3e
DH		 1046 KVM_SYNC_CRS |
1047 KVM_SYNC_ARCH0 |
1048 KVM_SYNC_PFAULT;
dafd032a
DD		 1049
1050 if (kvm_is_ucontrol(vcpu->kvm))
1051 return __kvm_ucontrol_vcpu_init(vcpu);
1052
b0c632db
HC		 1053 return 0;
1054}
1055
b0c632db
HC		 1056void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
1057{
4725c860
MS		 1058 save_fp_ctl(&vcpu->arch.host_fpregs.fpc);
1059 save_fp_regs(vcpu->arch.host_fpregs.fprs);
b0c632db 1060 save_access_regs(vcpu->arch.host_acrs);
4725c860
MS		 1061 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1062 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
59674c1a 1063 restore_access_regs(vcpu->run->s.regs.acrs);
480e5926 1064 gmap_enable(vcpu->arch.gmap);
9e6dabef 1065 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
b0c632db
HC		 1066}
1067
1068void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
1069{
9e6dabef 1070 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
480e5926 1071 gmap_disable(vcpu->arch.gmap);
4725c860
MS		 1072 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1073 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
59674c1a 1074 save_access_regs(vcpu->run->s.regs.acrs);
4725c860
MS		 1075 restore_fp_ctl(&vcpu->arch.host_fpregs.fpc);
1076 restore_fp_regs(vcpu->arch.host_fpregs.fprs);
b0c632db
HC		 1077 restore_access_regs(vcpu->arch.host_acrs);
1078}
1079
1080static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
1081{
1082 /* this equals initial cpu reset in pop, but we don't switch to ESA */
1083 vcpu->arch.sie_block->gpsw.mask = 0UL;
1084 vcpu->arch.sie_block->gpsw.addr = 0UL;
8d26cf7b 1085 kvm_s390_set_prefix(vcpu, 0);
b0c632db
HC		 1086 vcpu->arch.sie_block->cputm = 0UL;
1087 vcpu->arch.sie_block->ckc = 0UL;
1088 vcpu->arch.sie_block->todpr = 0;
1089 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
1090 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
1091 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
1092 vcpu->arch.guest_fpregs.fpc = 0;
1093 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
1094 vcpu->arch.sie_block->gbea = 1;
672550fb 1095 vcpu->arch.sie_block->pp = 0;
3c038e6b
DD		 1096 vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
1097 kvm_clear_async_pf_completion_queue(vcpu);
6352e4d2
DH		 1098 if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm))
1099 kvm_s390_vcpu_stop(vcpu);
2ed10cc1 1100 kvm_s390_clear_local_irqs(vcpu);
b0c632db
HC		 1101}
1102
31928aa5 1103void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
42897d86 1104{
72f25020
JH		 1105 mutex_lock(&vcpu->kvm->lock);
1106 vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch;
1107 mutex_unlock(&vcpu->kvm->lock);
dafd032a
DD		 1108 if (!kvm_is_ucontrol(vcpu->kvm))
1109 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
42897d86
MT		 1110}
1111
5102ee87
TK		 1112static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu)
1113{
9d8d5786 1114 if (!test_kvm_facility(vcpu->kvm, 76))
5102ee87
TK		 1115 return;
1116
a374e892
TK		 1117 vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA);
1118
1119 if (vcpu->kvm->arch.crypto.aes_kw)
1120 vcpu->arch.sie_block->ecb3 |= ECB3_AES;
1121 if (vcpu->kvm->arch.crypto.dea_kw)
1122 vcpu->arch.sie_block->ecb3 |= ECB3_DEA;
1123
5102ee87
TK		 1124 vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd;
1125}
1126
b31605c1
DD		 1127void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu)
1128{
1129 free_page(vcpu->arch.sie_block->cbrlo);
1130 vcpu->arch.sie_block->cbrlo = 0;
1131}
1132
1133int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu)
1134{
1135 vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL);
1136 if (!vcpu->arch.sie_block->cbrlo)
1137 return -ENOMEM;
1138
1139 vcpu->arch.sie_block->ecb2 |= 0x80;
1140 vcpu->arch.sie_block->ecb2 &= ~0x08;
1141 return 0;
1142}
1143
b0c632db
HC		 1144int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
1145{
b31605c1 1146 int rc = 0;
b31288fa 1147
9e6dabef
CH		 1148 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
1149 CPUSTAT_SM |
69d0d3a3
CB		 1150 CPUSTAT_STOPPED |
1151 CPUSTAT_GED);
fc34531d 1152 vcpu->arch.sie_block->ecb = 6;
9d8d5786 1153 if (test_kvm_facility(vcpu->kvm, 50) && test_kvm_facility(vcpu->kvm, 73))
7feb6bb8
MM		 1154 vcpu->arch.sie_block->ecb |= 0x10;
1155
69d0d3a3 1156 vcpu->arch.sie_block->ecb2 = 8;
ea5f4969 1157 vcpu->arch.sie_block->eca = 0xC1002000U;
217a4406
HC		 1158 if (sclp_has_siif())
1159 vcpu->arch.sie_block->eca |= 1;
ea5f4969
DH		 1160 if (sclp_has_sigpif())
1161 vcpu->arch.sie_block->eca |= 0x10000000U;
5a5e6536
MR		 1162 vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE |
1163 ICTL_TPROT;
1164
b31605c1
DD		 1165 if (kvm_s390_cmma_enabled(vcpu->kvm)) {
1166 rc = kvm_s390_vcpu_setup_cmma(vcpu);
1167 if (rc)
1168 return rc;
b31288fa 1169 }
0ac96caf 1170 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ca872302 1171 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
9d8d5786 1172
658b6eda 1173 mutex_lock(&vcpu->kvm->lock);
9d8d5786
MM		 1174 vcpu->arch.cpu_id = vcpu->kvm->arch.model.cpu_id;
1175 memcpy(vcpu->kvm->arch.model.fac->sie, vcpu->kvm->arch.model.fac->kvm,
1176 S390_ARCH_FAC_LIST_SIZE_BYTE);
658b6eda
MM		 1177 vcpu->arch.sie_block->ibc = vcpu->kvm->arch.model.ibc;
1178 mutex_unlock(&vcpu->kvm->lock);
5102ee87
TK		 1179
1180 kvm_s390_vcpu_crypto_setup(vcpu);
1181
b31605c1 1182 return rc;
b0c632db
HC		 1183}
1184
1185struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
1186 unsigned int id)
1187{
4d47555a 1188 struct kvm_vcpu *vcpu;
7feb6bb8 1189 struct sie_page *sie_page;
4d47555a
CO		 1190 int rc = -EINVAL;
1191
1192 if (id >= KVM_MAX_VCPUS)
1193 goto out;
1194
1195 rc = -ENOMEM;
b0c632db 1196
b110feaf 1197 vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
b0c632db 1198 if (!vcpu)
4d47555a 1199 goto out;
b0c632db 1200
7feb6bb8
MM		 1201 sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
1202 if (!sie_page)
b0c632db
HC		 1203 goto out_free_cpu;
1204
7feb6bb8
MM		 1205 vcpu->arch.sie_block = &sie_page->sie_block;
1206 vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;
1207
b0c632db 1208 vcpu->arch.sie_block->icpua = id;
58f9460b
CO		 1209 if (!kvm_is_ucontrol(kvm)) {
1210 if (!kvm->arch.sca) {
1211 WARN_ON_ONCE(1);
1212 goto out_free_cpu;
1213 }
1214 if (!kvm->arch.sca->cpu[id].sda)
1215 kvm->arch.sca->cpu[id].sda =
1216 (__u64) vcpu->arch.sie_block;
1217 vcpu->arch.sie_block->scaoh =
1218 (__u32)(((__u64)kvm->arch.sca) >> 32);
1219 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
1220 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
1221 }
9d8d5786 1222 vcpu->arch.sie_block->fac = (int) (long) kvm->arch.model.fac->sie;
b0c632db 1223
ba5c1e9b 1224 spin_lock_init(&vcpu->arch.local_int.lock);
ba5c1e9b 1225 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
d0321a24 1226 vcpu->arch.local_int.wq = &vcpu->wq;
5288fbf0 1227 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
ba5c1e9b 1228
b0c632db
HC		 1229 rc = kvm_vcpu_init(vcpu, kvm, id);
1230 if (rc)
7b06bf2f 1231 goto out_free_sie_block;
b0c632db
HC		 1232 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
1233 vcpu->arch.sie_block);
ade38c31 1234 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
b0c632db 1235
b0c632db 1236 return vcpu;
7b06bf2f
WY		 1237out_free_sie_block:
1238 free_page((unsigned long)(vcpu->arch.sie_block));
b0c632db 1239out_free_cpu:
b110feaf 1240 kmem_cache_free(kvm_vcpu_cache, vcpu);
4d47555a 1241out:
b0c632db
HC		 1242 return ERR_PTR(rc);
1243}
1244
b0c632db
HC		 1245int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
1246{
9a022067 1247 return kvm_s390_vcpu_has_irq(vcpu, 0);
b0c632db
HC		 1248}
1249
49b99e1e
CB		 1250void s390_vcpu_block(struct kvm_vcpu *vcpu)
1251{
1252 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
1253}
1254
1255void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
1256{
1257 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
1258}
1259
1260/*
1261 * Kick a guest cpu out of SIE and wait until SIE is not running.
1262 * If the CPU is not running (e.g. waiting as idle) the function will
1263 * return immediately. */
1264void exit_sie(struct kvm_vcpu *vcpu)
1265{
1266 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
1267 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
1268 cpu_relax();
1269}
1270
1271/* Kick a guest cpu out of SIE and prevent SIE-reentry */
1272void exit_sie_sync(struct kvm_vcpu *vcpu)
1273{
1274 s390_vcpu_block(vcpu);
1275 exit_sie(vcpu);
1276}
1277
2c70fe44
CB		 1278static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
1279{
1280 int i;
1281 struct kvm *kvm = gmap->private;
1282 struct kvm_vcpu *vcpu;
1283
1284 kvm_for_each_vcpu(i, vcpu, kvm) {
1285 /* match against both prefix pages */
fda902cb 1286 if (kvm_s390_get_prefix(vcpu) == (address & ~0x1000UL)) {
2c70fe44
CB		 1287 VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
1288 kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
1289 exit_sie_sync(vcpu);
1290 }
1291 }
1292}
1293
b6d33834
CD		 1294int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
1295{
1296 /* kvm common code refers to this, but never calls it */
1297 BUG();
1298 return 0;
1299}
1300
14eebd91
CO		 1301static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
1302 struct kvm_one_reg *reg)
1303{
1304 int r = -EINVAL;
1305
1306 switch (reg->id) {
29b7c71b
CO		 1307 case KVM_REG_S390_TODPR:
1308 r = put_user(vcpu->arch.sie_block->todpr,
1309 (u32 __user *)reg->addr);
1310 break;
1311 case KVM_REG_S390_EPOCHDIFF:
1312 r = put_user(vcpu->arch.sie_block->epoch,
1313 (u64 __user *)reg->addr);
1314 break;
46a6dd1c
J		 1315 case KVM_REG_S390_CPU_TIMER:
1316 r = put_user(vcpu->arch.sie_block->cputm,
1317 (u64 __user *)reg->addr);
1318 break;
1319 case KVM_REG_S390_CLOCK_COMP:
1320 r = put_user(vcpu->arch.sie_block->ckc,
1321 (u64 __user *)reg->addr);
1322 break;
536336c2
DD		 1323 case KVM_REG_S390_PFTOKEN:
1324 r = put_user(vcpu->arch.pfault_token,
1325 (u64 __user *)reg->addr);
1326 break;
1327 case KVM_REG_S390_PFCOMPARE:
1328 r = put_user(vcpu->arch.pfault_compare,
1329 (u64 __user *)reg->addr);
1330 break;
1331 case KVM_REG_S390_PFSELECT:
1332 r = put_user(vcpu->arch.pfault_select,
1333 (u64 __user *)reg->addr);
1334 break;
672550fb
CB		 1335 case KVM_REG_S390_PP:
1336 r = put_user(vcpu->arch.sie_block->pp,
1337 (u64 __user *)reg->addr);
1338 break;
afa45ff5
CB		 1339 case KVM_REG_S390_GBEA:
1340 r = put_user(vcpu->arch.sie_block->gbea,
1341 (u64 __user *)reg->addr);
1342 break;
14eebd91
CO		 1343 default:
1344 break;
1345 }
1346
1347 return r;
1348}
1349
1350static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
1351 struct kvm_one_reg *reg)
1352{
1353 int r = -EINVAL;
1354
1355 switch (reg->id) {
29b7c71b
CO		 1356 case KVM_REG_S390_TODPR:
1357 r = get_user(vcpu->arch.sie_block->todpr,
1358 (u32 __user *)reg->addr);
1359 break;
1360 case KVM_REG_S390_EPOCHDIFF:
1361 r = get_user(vcpu->arch.sie_block->epoch,
1362 (u64 __user *)reg->addr);
1363 break;
46a6dd1c
J		 1364 case KVM_REG_S390_CPU_TIMER:
1365 r = get_user(vcpu->arch.sie_block->cputm,
1366 (u64 __user *)reg->addr);
1367 break;
1368 case KVM_REG_S390_CLOCK_COMP:
1369 r = get_user(vcpu->arch.sie_block->ckc,
1370 (u64 __user *)reg->addr);
1371 break;
536336c2
DD		 1372 case KVM_REG_S390_PFTOKEN:
1373 r = get_user(vcpu->arch.pfault_token,
1374 (u64 __user *)reg->addr);
9fbd8082
DH		 1375 if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
1376 kvm_clear_async_pf_completion_queue(vcpu);
536336c2
DD		 1377 break;
1378 case KVM_REG_S390_PFCOMPARE:
1379 r = get_user(vcpu->arch.pfault_compare,
1380 (u64 __user *)reg->addr);
1381 break;
1382 case KVM_REG_S390_PFSELECT:
1383 r = get_user(vcpu->arch.pfault_select,
1384 (u64 __user *)reg->addr);
1385 break;
672550fb
CB		 1386 case KVM_REG_S390_PP:
1387 r = get_user(vcpu->arch.sie_block->pp,
1388 (u64 __user *)reg->addr);
1389 break;
afa45ff5
CB		 1390 case KVM_REG_S390_GBEA:
1391 r = get_user(vcpu->arch.sie_block->gbea,
1392 (u64 __user *)reg->addr);
1393 break;
14eebd91
CO		 1394 default:
1395 break;
1396 }
1397
1398 return r;
1399}
b6d33834 1400
b0c632db
HC		 1401static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
1402{
b0c632db 1403 kvm_s390_vcpu_initial_reset(vcpu);
b0c632db
HC		 1404 return 0;
1405}
1406
1407int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
1408{
5a32c1af 1409 memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
b0c632db
HC		 1410 return 0;
1411}
1412
1413int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
1414{
5a32c1af 1415 memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
b0c632db
HC		 1416 return 0;
1417}
1418
1419int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
1420 struct kvm_sregs *sregs)
1421{
59674c1a 1422 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
b0c632db 1423 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
59674c1a 1424 restore_access_regs(vcpu->run->s.regs.acrs);
b0c632db
HC		 1425 return 0;
1426}
1427
1428int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
1429 struct kvm_sregs *sregs)
1430{
59674c1a 1431 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
b0c632db 1432 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
b0c632db
HC		 1433 return 0;
1434}
1435
1436int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
1437{
4725c860
MS		 1438 if (test_fp_ctl(fpu->fpc))
1439 return -EINVAL;
b0c632db 1440 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
4725c860
MS		 1441 vcpu->arch.guest_fpregs.fpc = fpu->fpc;
1442 restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1443 restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
b0c632db
HC		 1444 return 0;
1445}
1446
1447int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
1448{
b0c632db
HC		 1449 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
1450 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
b0c632db
HC		 1451 return 0;
1452}
1453
1454static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
1455{
1456 int rc = 0;
1457
7a42fdc2 1458 if (!is_vcpu_stopped(vcpu))
b0c632db 1459 rc = -EBUSY;
d7b0b5eb
CO		 1460 else {
1461 vcpu->run->psw_mask = psw.mask;
1462 vcpu->run->psw_addr = psw.addr;
1463 }
b0c632db
HC		 1464 return rc;
1465}
1466
1467int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
1468 struct kvm_translation *tr)
1469{
1470 return -EINVAL; /* not implemented yet */
1471}
1472
27291e21
DH		 1473#define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \
1474 KVM_GUESTDBG_USE_HW_BP | \
1475 KVM_GUESTDBG_ENABLE)
1476
d0bfb940
JK		 1477int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
1478 struct kvm_guest_debug *dbg)
b0c632db 1479{
27291e21
DH		 1480 int rc = 0;
1481
1482 vcpu->guest_debug = 0;
1483 kvm_s390_clear_bp_data(vcpu);
1484
2de3bfc2 1485 if (dbg->control & ~VALID_GUESTDBG_FLAGS)
27291e21
DH		 1486 return -EINVAL;
1487
1488 if (dbg->control & KVM_GUESTDBG_ENABLE) {
1489 vcpu->guest_debug = dbg->control;
1490 /* enforce guest PER */
1491 atomic_set_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
1492
1493 if (dbg->control & KVM_GUESTDBG_USE_HW_BP)
1494 rc = kvm_s390_import_bp_data(vcpu, dbg);
1495 } else {
1496 atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
1497 vcpu->arch.guestdbg.last_bp = 0;
1498 }
1499
1500 if (rc) {
1501 vcpu->guest_debug = 0;
1502 kvm_s390_clear_bp_data(vcpu);
1503 atomic_clear_mask(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
1504 }
1505
1506 return rc;
b0c632db
HC		 1507}
1508
62d9f0db
MT		 1509int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
1510 struct kvm_mp_state *mp_state)
1511{
6352e4d2
DH		 1512 /* CHECK_STOP and LOAD are not supported yet */
1513 return is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED :
1514 KVM_MP_STATE_OPERATING;
62d9f0db
MT		 1515}
1516
1517int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
1518 struct kvm_mp_state *mp_state)
1519{
6352e4d2
DH		 1520 int rc = 0;
1521
1522 /* user space knows about this interface - let it control the state */
1523 vcpu->kvm->arch.user_cpu_state_ctrl = 1;
1524
1525 switch (mp_state->mp_state) {
1526 case KVM_MP_STATE_STOPPED:
1527 kvm_s390_vcpu_stop(vcpu);
1528 break;
1529 case KVM_MP_STATE_OPERATING:
1530 kvm_s390_vcpu_start(vcpu);
1531 break;
1532 case KVM_MP_STATE_LOAD:
1533 case KVM_MP_STATE_CHECK_STOP:
1534 /* fall through - CHECK_STOP and LOAD are not supported yet */
1535 default:
1536 rc = -ENXIO;
1537 }
1538
1539 return rc;
62d9f0db
MT		 1540}
1541
b31605c1
DD		 1542bool kvm_s390_cmma_enabled(struct kvm *kvm)
1543{
1544 if (!MACHINE_IS_LPAR)
1545 return false;
1546 /* only enable for z10 and later */
1547 if (!MACHINE_HAS_EDAT1)
1548 return false;
1549 if (!kvm->arch.use_cmma)
1550 return false;
1551 return true;
1552}
1553
8ad35755
DH		 1554static bool ibs_enabled(struct kvm_vcpu *vcpu)
1555{
1556 return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS;
1557}
1558
2c70fe44
CB		 1559static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
1560{
8ad35755
DH		 1561retry:
1562 s390_vcpu_unblock(vcpu);
2c70fe44
CB		 1563 /*
1564 * We use MMU_RELOAD just to re-arm the ipte notifier for the
1565 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
1566 * This ensures that the ipte instruction for this request has
1567 * already finished. We might race against a second unmapper that
1568 * wants to set the blocking bit. Lets just retry the request loop.
1569 */
8ad35755 1570 if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
2c70fe44
CB		 1571 int rc;
1572 rc = gmap_ipte_notify(vcpu->arch.gmap,
fda902cb 1573 kvm_s390_get_prefix(vcpu),
2c70fe44
CB		 1574 PAGE_SIZE * 2);
1575 if (rc)
1576 return rc;
8ad35755 1577 goto retry;
2c70fe44 1578 }
8ad35755 1579
d3d692c8
DH		 1580 if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) {
1581 vcpu->arch.sie_block->ihcpu = 0xffff;
1582 goto retry;
1583 }
1584
8ad35755
DH		 1585 if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) {
1586 if (!ibs_enabled(vcpu)) {
1587 trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1);
1588 atomic_set_mask(CPUSTAT_IBS,
1589 &vcpu->arch.sie_block->cpuflags);
1590 }
1591 goto retry;
2c70fe44 1592 }
8ad35755
DH		 1593
1594 if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) {
1595 if (ibs_enabled(vcpu)) {
1596 trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0);
1597 atomic_clear_mask(CPUSTAT_IBS,
1598 &vcpu->arch.sie_block->cpuflags);
1599 }
1600 goto retry;
1601 }
1602
0759d068
DH		 1603 /* nothing to do, just clear the request */
1604 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
1605
2c70fe44
CB		 1606 return 0;
1607}
1608
fa576c58
TH		 1609/**
1610 * kvm_arch_fault_in_page - fault-in guest page if necessary
1611 * @vcpu: The corresponding virtual cpu
1612 * @gpa: Guest physical address
1613 * @writable: Whether the page should be writable or not
1614 *
1615 * Make sure that a guest page has been faulted-in on the host.
1616 *
1617 * Return: Zero on success, negative error code otherwise.
1618 */
1619long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable)
24eb3a82 1620{
527e30b4
MS		 1621 return gmap_fault(vcpu->arch.gmap, gpa,
1622 writable ? FAULT_FLAG_WRITE : 0);
24eb3a82
DD		 1623}
1624
3c038e6b
DD		 1625static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
1626 unsigned long token)
1627{
1628 struct kvm_s390_interrupt inti;
383d0b05 1629 struct kvm_s390_irq irq;
3c038e6b
DD		 1630
1631 if (start_token) {
383d0b05
JF		 1632 irq.u.ext.ext_params2 = token;
1633 irq.type = KVM_S390_INT_PFAULT_INIT;
1634 WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq));
3c038e6b
DD		 1635 } else {
1636 inti.type = KVM_S390_INT_PFAULT_DONE;
383d0b05 1637 inti.parm64 = token;
3c038e6b
DD		 1638 WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
1639 }
1640}
1641
1642void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
1643 struct kvm_async_pf *work)
1644{
1645 trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
1646 __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
1647}
1648
1649void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
1650 struct kvm_async_pf *work)
1651{
1652 trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
1653 __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
1654}
1655
1656void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
1657 struct kvm_async_pf *work)
1658{
1659 /* s390 will always inject the page directly */
1660}
1661
1662bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
1663{
1664 /*
1665 * s390 will always inject the page directly,
1666 * but we still want check_async_completion to cleanup
1667 */
1668 return true;
1669}
1670
1671static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
1672{
1673 hva_t hva;
1674 struct kvm_arch_async_pf arch;
1675 int rc;
1676
1677 if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
1678 return 0;
1679 if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
1680 vcpu->arch.pfault_compare)
1681 return 0;
1682 if (psw_extint_disabled(vcpu))
1683 return 0;
9a022067 1684 if (kvm_s390_vcpu_has_irq(vcpu, 0))
3c038e6b
DD		 1685 return 0;
1686 if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul))
1687 return 0;
1688 if (!vcpu->arch.gmap->pfault_enabled)
1689 return 0;
1690
81480cc1
HC		 1691 hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr));
1692 hva += current->thread.gmap_addr & ~PAGE_MASK;
1693 if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8))
3c038e6b
DD		 1694 return 0;
1695
1696 rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
1697 return rc;
1698}
1699
3fb4c40f 1700static int vcpu_pre_run(struct kvm_vcpu *vcpu)
b0c632db 1701{
3fb4c40f 1702 int rc, cpuflags;
e168bf8d 1703
3c038e6b
DD		 1704 /*
1705 * On s390 notifications for arriving pages will be delivered directly
1706 * to the guest but the house keeping for completed pfaults is
1707 * handled outside the worker.
1708 */
1709 kvm_check_async_pf_completion(vcpu);
1710
5a32c1af 1711 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
b0c632db
HC		 1712
1713 if (need_resched())
1714 schedule();
1715
d3a73acb 1716 if (test_cpu_flag(CIF_MCCK_PENDING))
71cde587
CB		 1717 s390_handle_mcck();
1718
79395031
JF		 1719 if (!kvm_is_ucontrol(vcpu->kvm)) {
1720 rc = kvm_s390_deliver_pending_interrupts(vcpu);
1721 if (rc)
1722 return rc;
1723 }
0ff31867 1724
2c70fe44
CB		 1725 rc = kvm_s390_handle_requests(vcpu);
1726 if (rc)
1727 return rc;
1728
27291e21
DH		 1729 if (guestdbg_enabled(vcpu)) {
1730 kvm_s390_backup_guest_per_regs(vcpu);
1731 kvm_s390_patch_guest_per_regs(vcpu);
1732 }
1733
b0c632db 1734 vcpu->arch.sie_block->icptcode = 0;
3fb4c40f
TH		 1735 cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
1736 VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
1737 trace_kvm_s390_sie_enter(vcpu, cpuflags);
2b29a9fd 1738
3fb4c40f
TH		 1739 return 0;
1740}
1741
1742static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
1743{
24eb3a82 1744 int rc = -1;
2b29a9fd
DD		 1745
1746 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
1747 vcpu->arch.sie_block->icptcode);
1748 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
1749
27291e21
DH		 1750 if (guestdbg_enabled(vcpu))
1751 kvm_s390_restore_guest_per_regs(vcpu);
1752
3fb4c40f 1753 if (exit_reason >= 0) {
7c470539 1754 rc = 0;
210b1607
TH		 1755 } else if (kvm_is_ucontrol(vcpu->kvm)) {
1756 vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
1757 vcpu->run->s390_ucontrol.trans_exc_code =
1758 current->thread.gmap_addr;
1759 vcpu->run->s390_ucontrol.pgm_code = 0x10;
1760 rc = -EREMOTE;
24eb3a82
DD		 1761
1762 } else if (current->thread.gmap_pfault) {
3c038e6b 1763 trace_kvm_s390_major_guest_pfault(vcpu);
24eb3a82 1764 current->thread.gmap_pfault = 0;
fa576c58 1765 if (kvm_arch_setup_async_pf(vcpu)) {
24eb3a82 1766 rc = 0;
fa576c58
TH		 1767 } else {
1768 gpa_t gpa = current->thread.gmap_addr;
1769 rc = kvm_arch_fault_in_page(vcpu, gpa, 1);
1770 }
24eb3a82
DD		 1771 }
1772
1773 if (rc == -1) {
699bde3b
CB		 1774 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
1775 trace_kvm_s390_sie_fault(vcpu);
1776 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
1f0d0f09 1777 }
b0c632db 1778
5a32c1af 1779 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
3fb4c40f 1780
a76ccff6
TH		 1781 if (rc == 0) {
1782 if (kvm_is_ucontrol(vcpu->kvm))
2955c83f
CB		 1783 /* Don't exit for host interrupts. */
1784 rc = vcpu->arch.sie_block->icptcode ? -EOPNOTSUPP : 0;
a76ccff6
TH		 1785 else
1786 rc = kvm_handle_sie_intercept(vcpu);
1787 }
1788
3fb4c40f
TH		 1789 return rc;
1790}
1791
1792static int __vcpu_run(struct kvm_vcpu *vcpu)
1793{
1794 int rc, exit_reason;
1795
800c1065
TH		 1796 /*
1797 * We try to hold kvm->srcu during most of vcpu_run (except when run-
1798 * ning the guest), so that memslots (and other stuff) are protected
1799 */
1800 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
1801
a76ccff6
TH		 1802 do {
1803 rc = vcpu_pre_run(vcpu);
1804 if (rc)
1805 break;
3fb4c40f 1806
800c1065 1807 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
a76ccff6
TH		 1808 /*
1809 * As PF_VCPU will be used in fault handler, between
1810 * guest_enter and guest_exit should be no uaccess.
1811 */
1812 preempt_disable();
1813 kvm_guest_enter();
1814 preempt_enable();
1815 exit_reason = sie64a(vcpu->arch.sie_block,
1816 vcpu->run->s.regs.gprs);
1817 kvm_guest_exit();
800c1065 1818 vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
a76ccff6
TH		 1819
1820 rc = vcpu_post_run(vcpu, exit_reason);
27291e21 1821 } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc);
3fb4c40f 1822
800c1065 1823 srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
e168bf8d 1824 return rc;
b0c632db
HC		 1825}
1826
b028ee3e
DH		 1827static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1828{
1829 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
1830 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
1831 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX)
1832 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
1833 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
1834 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
d3d692c8
DH		 1835 /* some control register changes require a tlb flush */
1836 kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
b028ee3e
DH		 1837 }
1838 if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) {
1839 vcpu->arch.sie_block->cputm = kvm_run->s.regs.cputm;
1840 vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc;
1841 vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr;
1842 vcpu->arch.sie_block->pp = kvm_run->s.regs.pp;
1843 vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea;
1844 }
1845 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) {
1846 vcpu->arch.pfault_token = kvm_run->s.regs.pft;
1847 vcpu->arch.pfault_select = kvm_run->s.regs.pfs;
1848 vcpu->arch.pfault_compare = kvm_run->s.regs.pfc;
9fbd8082
DH		 1849 if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
1850 kvm_clear_async_pf_completion_queue(vcpu);
b028ee3e
DH		 1851 }
1852 kvm_run->kvm_dirty_regs = 0;
1853}
1854
1855static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1856{
1857 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
1858 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
1859 kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu);
1860 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
1861 kvm_run->s.regs.cputm = vcpu->arch.sie_block->cputm;
1862 kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc;
1863 kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr;
1864 kvm_run->s.regs.pp = vcpu->arch.sie_block->pp;
1865 kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea;
1866 kvm_run->s.regs.pft = vcpu->arch.pfault_token;
1867 kvm_run->s.regs.pfs = vcpu->arch.pfault_select;
1868 kvm_run->s.regs.pfc = vcpu->arch.pfault_compare;
1869}
1870
b0c632db
HC		 1871int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
1872{
8f2abe6a 1873 int rc;
b0c632db
HC		 1874 sigset_t sigsaved;
1875
27291e21
DH		 1876 if (guestdbg_exit_pending(vcpu)) {
1877 kvm_s390_prepare_debug_exit(vcpu);
1878 return 0;
1879 }
1880
b0c632db
HC		 1881 if (vcpu->sigset_active)
1882 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
1883
6352e4d2
DH		 1884 if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) {
1885 kvm_s390_vcpu_start(vcpu);
1886 } else if (is_vcpu_stopped(vcpu)) {
1887 pr_err_ratelimited("kvm-s390: can't run stopped vcpu %d\n",
1888 vcpu->vcpu_id);
1889 return -EINVAL;
1890 }
b0c632db 1891
b028ee3e 1892 sync_regs(vcpu, kvm_run);
d7b0b5eb 1893
dab4079d 1894 might_fault();
a76ccff6 1895 rc = __vcpu_run(vcpu);
9ace903d 1896
b1d16c49
CE		 1897 if (signal_pending(current) && !rc) {
1898 kvm_run->exit_reason = KVM_EXIT_INTR;
8f2abe6a 1899 rc = -EINTR;
b1d16c49 1900 }
8f2abe6a 1901
27291e21
DH		 1902 if (guestdbg_exit_pending(vcpu) && !rc) {
1903 kvm_s390_prepare_debug_exit(vcpu);
1904 rc = 0;
1905 }
1906
b8e660b8 1907 if (rc == -EOPNOTSUPP) {
8f2abe6a
CB		 1908 /* intercept cannot be handled in-kernel, prepare kvm-run */
1909 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
1910 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
8f2abe6a
CB		 1911 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
1912 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
1913 rc = 0;
1914 }
1915
1916 if (rc == -EREMOTE) {
1917 /* intercept was handled, but userspace support is needed
1918 * kvm_run has been prepared by the handler */
1919 rc = 0;
1920 }
b0c632db 1921
b028ee3e 1922 store_regs(vcpu, kvm_run);
d7b0b5eb 1923
b0c632db
HC		 1924 if (vcpu->sigset_active)
1925 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1926
b0c632db 1927 vcpu->stat.exit_userspace++;
7e8e6ab4 1928 return rc;
b0c632db
HC		 1929}
1930
b0c632db
HC		 1931/*
1932 * store status at address
1933 * we use have two special cases:
1934 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
1935 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
1936 */
d0bce605 1937int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa)
b0c632db 1938{
092670cd 1939 unsigned char archmode = 1;
fda902cb 1940 unsigned int px;
178bd789 1941 u64 clkcomp;
d0bce605 1942 int rc;
b0c632db 1943
d0bce605
HC		 1944 if (gpa == KVM_S390_STORE_STATUS_NOADDR) {
1945 if (write_guest_abs(vcpu, 163, &archmode, 1))
b0c632db 1946 return -EFAULT;
d0bce605
HC		 1947 gpa = SAVE_AREA_BASE;
1948 } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) {
1949 if (write_guest_real(vcpu, 163, &archmode, 1))
b0c632db 1950 return -EFAULT;
d0bce605
HC		 1951 gpa = kvm_s390_real_to_abs(vcpu, SAVE_AREA_BASE);
1952 }
1953 rc = write_guest_abs(vcpu, gpa + offsetof(struct save_area, fp_regs),
1954 vcpu->arch.guest_fpregs.fprs, 128);
1955 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, gp_regs),
1956 vcpu->run->s.regs.gprs, 128);
1957 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, psw),
1958 &vcpu->arch.sie_block->gpsw, 16);
fda902cb 1959 px = kvm_s390_get_prefix(vcpu);
d0bce605 1960 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, pref_reg),
fda902cb 1961 &px, 4);
d0bce605
HC		 1962 rc |= write_guest_abs(vcpu,
1963 gpa + offsetof(struct save_area, fp_ctrl_reg),
1964 &vcpu->arch.guest_fpregs.fpc, 4);
1965 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, tod_reg),
1966 &vcpu->arch.sie_block->todpr, 4);
1967 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, timer),
1968 &vcpu->arch.sie_block->cputm, 8);
178bd789 1969 clkcomp = vcpu->arch.sie_block->ckc >> 8;
d0bce605
HC		 1970 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, clk_cmp),
1971 &clkcomp, 8);
1972 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, acc_regs),
1973 &vcpu->run->s.regs.acrs, 64);
1974 rc |= write_guest_abs(vcpu, gpa + offsetof(struct save_area, ctrl_regs),
1975 &vcpu->arch.sie_block->gcr, 128);
1976 return rc ? -EFAULT : 0;
b0c632db
HC		 1977}
1978
e879892c
TH		 1979int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
1980{
1981 /*
1982 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
1983 * copying in vcpu load/put. Lets update our copies before we save
1984 * it into the save area
1985 */
1986 save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
1987 save_fp_regs(vcpu->arch.guest_fpregs.fprs);
1988 save_access_regs(vcpu->run->s.regs.acrs);
1989
1990 return kvm_s390_store_status_unloaded(vcpu, addr);
1991}
1992
8ad35755
DH		 1993static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
1994{
1995 kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu);
1996 kvm_make_request(KVM_REQ_DISABLE_IBS, vcpu);
1997 exit_sie_sync(vcpu);
1998}
1999
2000static void __disable_ibs_on_all_vcpus(struct kvm *kvm)
2001{
2002 unsigned int i;
2003 struct kvm_vcpu *vcpu;
2004
2005 kvm_for_each_vcpu(i, vcpu, kvm) {
2006 __disable_ibs_on_vcpu(vcpu);
2007 }
2008}
2009
2010static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
2011{
2012 kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu);
2013 kvm_make_request(KVM_REQ_ENABLE_IBS, vcpu);
2014 exit_sie_sync(vcpu);
2015}
2016
6852d7b6
DH		 2017void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu)
2018{
8ad35755
DH		 2019 int i, online_vcpus, started_vcpus = 0;
2020
2021 if (!is_vcpu_stopped(vcpu))
2022 return;
2023
6852d7b6 2024 trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1);
8ad35755 2025 /* Only one cpu at a time may enter/leave the STOPPED state. */
433b9ee4 2026 spin_lock(&vcpu->kvm->arch.start_stop_lock);
8ad35755
DH		 2027 online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
2028
2029 for (i = 0; i < online_vcpus; i++) {
2030 if (!is_vcpu_stopped(vcpu->kvm->vcpus[i]))
2031 started_vcpus++;
2032 }
2033
2034 if (started_vcpus == 0) {
2035 /* we're the only active VCPU -> speed it up */
2036 __enable_ibs_on_vcpu(vcpu);
2037 } else if (started_vcpus == 1) {
2038 /*
2039 * As we are starting a second VCPU, we have to disable
2040 * the IBS facility on all VCPUs to remove potentially
2041 * oustanding ENABLE requests.
2042 */
2043 __disable_ibs_on_all_vcpus(vcpu->kvm);
2044 }
2045
6852d7b6 2046 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
8ad35755
DH		 2047 /*
2048 * Another VCPU might have used IBS while we were offline.
2049 * Let's play safe and flush the VCPU at startup.
2050 */
d3d692c8 2051 kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
433b9ee4 2052 spin_unlock(&vcpu->kvm->arch.start_stop_lock);
8ad35755 2053 return;
6852d7b6
DH		 2054}
2055
2056void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu)
2057{
8ad35755
DH		 2058 int i, online_vcpus, started_vcpus = 0;
2059 struct kvm_vcpu *started_vcpu = NULL;
2060
2061 if (is_vcpu_stopped(vcpu))
2062 return;
2063
6852d7b6 2064 trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0);
8ad35755 2065 /* Only one cpu at a time may enter/leave the STOPPED state. */
433b9ee4 2066 spin_lock(&vcpu->kvm->arch.start_stop_lock);
8ad35755
DH		 2067 online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
2068
32f5ff63 2069 /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */
6cddd432 2070 kvm_s390_clear_stop_irq(vcpu);
32f5ff63 2071
6cddd432 2072 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
8ad35755
DH		 2073 __disable_ibs_on_vcpu(vcpu);
2074
2075 for (i = 0; i < online_vcpus; i++) {
2076 if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) {
2077 started_vcpus++;
2078 started_vcpu = vcpu->kvm->vcpus[i];
2079 }
2080 }
2081
2082 if (started_vcpus == 1) {
2083 /*
2084 * As we only have one VCPU left, we want to enable the
2085 * IBS facility for that VCPU to speed it up.
2086 */
2087 __enable_ibs_on_vcpu(started_vcpu);
2088 }
2089
433b9ee4 2090 spin_unlock(&vcpu->kvm->arch.start_stop_lock);
8ad35755 2091 return;
6852d7b6
DH		 2092}
2093
d6712df9
CH		 2094static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
2095 struct kvm_enable_cap *cap)
2096{
2097 int r;
2098
2099 if (cap->flags)
2100 return -EINVAL;
2101
2102 switch (cap->cap) {
fa6b7fe9
CH		 2103 case KVM_CAP_S390_CSS_SUPPORT:
2104 if (!vcpu->kvm->arch.css_support) {
2105 vcpu->kvm->arch.css_support = 1;
2106 trace_kvm_s390_enable_css(vcpu->kvm);
2107 }
2108 r = 0;
2109 break;
d6712df9
CH		 2110 default:
2111 r = -EINVAL;
2112 break;
2113 }
2114 return r;
2115}
2116
b0c632db
HC		 2117long kvm_arch_vcpu_ioctl(struct file *filp,
2118 unsigned int ioctl, unsigned long arg)
2119{
2120 struct kvm_vcpu *vcpu = filp->private_data;
2121 void __user *argp = (void __user *)arg;
800c1065 2122 int idx;
bc923cc9 2123 long r;
b0c632db 2124
93736624
AK		 2125 switch (ioctl) {
2126 case KVM_S390_INTERRUPT: {
ba5c1e9b 2127 struct kvm_s390_interrupt s390int;
383d0b05 2128 struct kvm_s390_irq s390irq;
ba5c1e9b 2129
93736624 2130 r = -EFAULT;
ba5c1e9b 2131 if (copy_from_user(&s390int, argp, sizeof(s390int)))
93736624 2132 break;
383d0b05
JF		 2133 if (s390int_to_s390irq(&s390int, &s390irq))
2134 return -EINVAL;
2135 r = kvm_s390_inject_vcpu(vcpu, &s390irq);
93736624 2136 break;
ba5c1e9b 2137 }
b0c632db 2138 case KVM_S390_STORE_STATUS:
800c1065 2139 idx = srcu_read_lock(&vcpu->kvm->srcu);
bc923cc9 2140 r = kvm_s390_vcpu_store_status(vcpu, arg);
800c1065 2141 srcu_read_unlock(&vcpu->kvm->srcu, idx);
bc923cc9 2142 break;
b0c632db
HC		 2143 case KVM_S390_SET_INITIAL_PSW: {
2144 psw_t psw;
2145
bc923cc9 2146 r = -EFAULT;
b0c632db 2147 if (copy_from_user(&psw, argp, sizeof(psw)))
bc923cc9
AK		 2148 break;
2149 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
2150 break;
b0c632db
HC		 2151 }
2152 case KVM_S390_INITIAL_RESET:
bc923cc9
AK		 2153 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
2154 break;
14eebd91
CO		 2155 case KVM_SET_ONE_REG:
2156 case KVM_GET_ONE_REG: {
2157 struct kvm_one_reg reg;
2158 r = -EFAULT;
2159 if (copy_from_user(&reg, argp, sizeof(reg)))
2160 break;
2161 if (ioctl == KVM_SET_ONE_REG)
2162 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
2163 else
2164 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
2165 break;
2166 }
27e0393f
CO		 2167#ifdef CONFIG_KVM_S390_UCONTROL
2168 case KVM_S390_UCAS_MAP: {
2169 struct kvm_s390_ucas_mapping ucasmap;
2170
2171 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
2172 r = -EFAULT;
2173 break;
2174 }
2175
2176 if (!kvm_is_ucontrol(vcpu->kvm)) {
2177 r = -EINVAL;
2178 break;
2179 }
2180
2181 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
2182 ucasmap.vcpu_addr, ucasmap.length);
2183 break;
2184 }
2185 case KVM_S390_UCAS_UNMAP: {
2186 struct kvm_s390_ucas_mapping ucasmap;
2187
2188 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
2189 r = -EFAULT;
2190 break;
2191 }
2192
2193 if (!kvm_is_ucontrol(vcpu->kvm)) {
2194 r = -EINVAL;
2195 break;
2196 }
2197
2198 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
2199 ucasmap.length);
2200 break;
2201 }
2202#endif
ccc7910f 2203 case KVM_S390_VCPU_FAULT: {
527e30b4 2204 r = gmap_fault(vcpu->arch.gmap, arg, 0);
ccc7910f
CO		 2205 break;
2206 }
d6712df9
CH		 2207 case KVM_ENABLE_CAP:
2208 {
2209 struct kvm_enable_cap cap;
2210 r = -EFAULT;
2211 if (copy_from_user(&cap, argp, sizeof(cap)))
2212 break;
2213 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
2214 break;
2215 }
b0c632db 2216 default:
3e6afcf1 2217 r = -ENOTTY;
b0c632db 2218 }
bc923cc9 2219 return r;
b0c632db
HC		 2220}
2221
5b1c1493
CO		 2222int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
2223{
2224#ifdef CONFIG_KVM_S390_UCONTROL
2225 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
2226 && (kvm_is_ucontrol(vcpu->kvm))) {
2227 vmf->page = virt_to_page(vcpu->arch.sie_block);
2228 get_page(vmf->page);
2229 return 0;
2230 }
2231#endif
2232 return VM_FAULT_SIGBUS;
2233}
2234
5587027c
AK		 2235int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
2236 unsigned long npages)
db3fe4eb
TY		 2237{
2238 return 0;
2239}
2240
b0c632db 2241/* Section: memory related */
f7784b8e
MT		 2242int kvm_arch_prepare_memory_region(struct kvm *kvm,
2243 struct kvm_memory_slot *memslot,
7b6195a9
TY		 2244 struct kvm_userspace_memory_region *mem,
2245 enum kvm_mr_change change)
b0c632db 2246{
dd2887e7
NW		 2247 /* A few sanity checks. We can have memory slots which have to be
2248 located/ended at a segment boundary (1MB). The memory in userland is
2249 ok to be fragmented into various different vmas. It is okay to mmap()
2250 and munmap() stuff in this slot after doing this call at any time */
b0c632db 2251
598841ca 2252 if (mem->userspace_addr & 0xffffful)
b0c632db
HC		 2253 return -EINVAL;
2254
598841ca 2255 if (mem->memory_size & 0xffffful)
b0c632db
HC		 2256 return -EINVAL;
2257
f7784b8e
MT		 2258 return 0;
2259}
2260
2261void kvm_arch_commit_memory_region(struct kvm *kvm,
2262 struct kvm_userspace_memory_region *mem,
8482644a
TY		 2263 const struct kvm_memory_slot *old,
2264 enum kvm_mr_change change)
f7784b8e 2265{
f7850c92 2266 int rc;
f7784b8e 2267
2cef4deb
CB		 2268 /* If the basics of the memslot do not change, we do not want
2269 * to update the gmap. Every update causes several unnecessary
2270 * segment translation exceptions. This is usually handled just
2271 * fine by the normal fault handler + gmap, but it will also
2272 * cause faults on the prefix page of running guest CPUs.
2273 */
2274 if (old->userspace_addr == mem->userspace_addr &&
2275 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
2276 old->npages * PAGE_SIZE == mem->memory_size)
2277 return;
598841ca
CO		 2278
2279 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
2280 mem->guest_phys_addr, mem->memory_size);
2281 if (rc)
f7850c92 2282 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
598841ca 2283 return;
b0c632db
HC		 2284}
2285
b0c632db
HC		 2286static int __init kvm_s390_init(void)
2287{
9d8d5786 2288 return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
b0c632db
HC		 2289}
2290
2291static void __exit kvm_s390_exit(void)
2292{
2293 kvm_exit();
2294}
2295
2296module_init(kvm_s390_init);
2297module_exit(kvm_s390_exit);
566af940
CH		 2298
2299/*
2300 * Enable autoloading of the kvm module.
2301 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
2302 * since x86 takes a different approach.
2303 */
2304#include <linux/miscdevice.h>
2305MODULE_ALIAS_MISCDEV(KVM_MINOR);
2306MODULE_ALIAS("devname:kvm");
Ubuntu Hirsute Linux kernel mirror