source: src/linux/universal/linux-4.9/arch/s390/kvm/kvm-s390.c @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 11 days ago

use new squashfs in all kernels

File size: 86.5 KB
Line 
1/*
2 * hosting zSeries kernel virtual machines
3 *
4 * Copyright IBM Corp. 2008, 2009
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License (version 2 only)
8 * as published by the Free Software Foundation.
9 *
10 *    Author(s): Carsten Otte <cotte@de.ibm.com>
11 *               Christian Borntraeger <borntraeger@de.ibm.com>
12 *               Heiko Carstens <heiko.carstens@de.ibm.com>
13 *               Christian Ehrhardt <ehrhardt@de.ibm.com>
14 *               Jason J. Herne <jjherne@us.ibm.com>
15 */
16
17#include <linux/compiler.h>
18#include <linux/err.h>
19#include <linux/fs.h>
20#include <linux/hrtimer.h>
21#include <linux/init.h>
22#include <linux/kvm.h>
23#include <linux/kvm_host.h>
24#include <linux/mman.h>
25#include <linux/module.h>
26#include <linux/random.h>
27#include <linux/slab.h>
28#include <linux/timer.h>
29#include <linux/vmalloc.h>
30#include <linux/bitmap.h>
31#include <asm/asm-offsets.h>
32#include <asm/lowcore.h>
33#include <asm/stp.h>
34#include <asm/pgtable.h>
35#include <asm/gmap.h>
36#include <asm/nmi.h>
37#include <asm/switch_to.h>
38#include <asm/isc.h>
39#include <asm/sclp.h>
40#include <asm/cpacf.h>
41#include <asm/timex.h>
42#include "kvm-s390.h"
43#include "gaccess.h"
44
45#define KMSG_COMPONENT "kvm-s390"
46#undef pr_fmt
47#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
48
49#define CREATE_TRACE_POINTS
50#include "trace.h"
51#include "trace-s390.h"
52
53#define MEM_OP_MAX_SIZE 65536   /* Maximum transfer size for KVM_S390_MEM_OP */
54#define LOCAL_IRQS 32
55#define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \
56                           (KVM_MAX_VCPUS + LOCAL_IRQS))
57
58#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
59
60struct kvm_stats_debugfs_item debugfs_entries[] = {
61        { "userspace_handled", VCPU_STAT(exit_userspace) },
62        { "exit_null", VCPU_STAT(exit_null) },
63        { "exit_validity", VCPU_STAT(exit_validity) },
64        { "exit_stop_request", VCPU_STAT(exit_stop_request) },
65        { "exit_external_request", VCPU_STAT(exit_external_request) },
66        { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
67        { "exit_instruction", VCPU_STAT(exit_instruction) },
68        { "exit_pei", VCPU_STAT(exit_pei) },
69        { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
70        { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
71        { "exit_operation_exception", VCPU_STAT(exit_operation_exception) },
72        { "halt_successful_poll", VCPU_STAT(halt_successful_poll) },
73        { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) },
74        { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) },
75        { "halt_wakeup", VCPU_STAT(halt_wakeup) },
76        { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
77        { "instruction_lctl", VCPU_STAT(instruction_lctl) },
78        { "instruction_stctl", VCPU_STAT(instruction_stctl) },
79        { "instruction_stctg", VCPU_STAT(instruction_stctg) },
80        { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
81        { "deliver_external_call", VCPU_STAT(deliver_external_call) },
82        { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
83        { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
84        { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
85        { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
86        { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
87        { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
88        { "exit_wait_state", VCPU_STAT(exit_wait_state) },
89        { "instruction_pfmf", VCPU_STAT(instruction_pfmf) },
90        { "instruction_stidp", VCPU_STAT(instruction_stidp) },
91        { "instruction_spx", VCPU_STAT(instruction_spx) },
92        { "instruction_stpx", VCPU_STAT(instruction_stpx) },
93        { "instruction_stap", VCPU_STAT(instruction_stap) },
94        { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
95        { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock) },
96        { "instruction_stsch", VCPU_STAT(instruction_stsch) },
97        { "instruction_chsc", VCPU_STAT(instruction_chsc) },
98        { "instruction_essa", VCPU_STAT(instruction_essa) },
99        { "instruction_stsi", VCPU_STAT(instruction_stsi) },
100        { "instruction_stfl", VCPU_STAT(instruction_stfl) },
101        { "instruction_tprot", VCPU_STAT(instruction_tprot) },
102        { "instruction_sthyi", VCPU_STAT(instruction_sthyi) },
103        { "instruction_sie", VCPU_STAT(instruction_sie) },
104        { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
105        { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
106        { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
107        { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
108        { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency) },
109        { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start) },
110        { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
111        { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status) },
112        { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status) },
113        { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status) },
114        { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
115        { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
116        { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
117        { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset) },
118        { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset) },
119        { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown) },
120        { "diagnose_10", VCPU_STAT(diagnose_10) },
121        { "diagnose_44", VCPU_STAT(diagnose_44) },
122        { "diagnose_9c", VCPU_STAT(diagnose_9c) },
123        { "diagnose_258", VCPU_STAT(diagnose_258) },
124        { "diagnose_308", VCPU_STAT(diagnose_308) },
125        { "diagnose_500", VCPU_STAT(diagnose_500) },
126        { NULL }
127};
128
129/* allow nested virtualization in KVM (if enabled by user space) */
130static int nested;
131module_param(nested, int, S_IRUGO);
132MODULE_PARM_DESC(nested, "Nested virtualization support");
133
134/* upper facilities limit for kvm */
135unsigned long kvm_s390_fac_list_mask[16] = { FACILITIES_KVM };
136
137unsigned long kvm_s390_fac_list_mask_size(void)
138{
139        BUILD_BUG_ON(ARRAY_SIZE(kvm_s390_fac_list_mask) > S390_ARCH_FAC_MASK_SIZE_U64);
140        return ARRAY_SIZE(kvm_s390_fac_list_mask);
141}
142
143/* available cpu features supported by kvm */
144static DECLARE_BITMAP(kvm_s390_available_cpu_feat, KVM_S390_VM_CPU_FEAT_NR_BITS);
145/* available subfunctions indicated via query / "test bit" */
146static struct kvm_s390_vm_cpu_subfunc kvm_s390_available_subfunc;
147
148static struct gmap_notifier gmap_notifier;
149static struct gmap_notifier vsie_gmap_notifier;
150debug_info_t *kvm_s390_dbf;
151
152/* Section: not file related */
153int kvm_arch_hardware_enable(void)
154{
155        /* every s390 is virtualization enabled ;-) */
156        return 0;
157}
158
159static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start,
160                              unsigned long end);
161
162/*
163 * This callback is executed during stop_machine(). All CPUs are therefore
164 * temporarily stopped. In order not to change guest behavior, we have to
165 * disable preemption whenever we touch the epoch of kvm and the VCPUs,
166 * so a CPU won't be stopped while calculating with the epoch.
167 */
168static int kvm_clock_sync(struct notifier_block *notifier, unsigned long val,
169                          void *v)
170{
171        struct kvm *kvm;
172        struct kvm_vcpu *vcpu;
173        int i;
174        unsigned long long *delta = v;
175
176        list_for_each_entry(kvm, &vm_list, vm_list) {
177                kvm->arch.epoch -= *delta;
178                kvm_for_each_vcpu(i, vcpu, kvm) {
179                        vcpu->arch.sie_block->epoch -= *delta;
180                        if (vcpu->arch.cputm_enabled)
181                                vcpu->arch.cputm_start += *delta;
182                        if (vcpu->arch.vsie_block)
183                                vcpu->arch.vsie_block->epoch -= *delta;
184                }
185        }
186        return NOTIFY_OK;
187}
188
189static struct notifier_block kvm_clock_notifier = {
190        .notifier_call = kvm_clock_sync,
191};
192
193int kvm_arch_hardware_setup(void)
194{
195        gmap_notifier.notifier_call = kvm_gmap_notifier;
196        gmap_register_pte_notifier(&gmap_notifier);
197        vsie_gmap_notifier.notifier_call = kvm_s390_vsie_gmap_notifier;
198        gmap_register_pte_notifier(&vsie_gmap_notifier);
199        atomic_notifier_chain_register(&s390_epoch_delta_notifier,
200                                       &kvm_clock_notifier);
201        return 0;
202}
203
204void kvm_arch_hardware_unsetup(void)
205{
206        gmap_unregister_pte_notifier(&gmap_notifier);
207        gmap_unregister_pte_notifier(&vsie_gmap_notifier);
208        atomic_notifier_chain_unregister(&s390_epoch_delta_notifier,
209                                         &kvm_clock_notifier);
210}
211
212static void allow_cpu_feat(unsigned long nr)
213{
214        set_bit_inv(nr, kvm_s390_available_cpu_feat);
215}
216
217static inline int plo_test_bit(unsigned char nr)
218{
219        register unsigned long r0 asm("0") = (unsigned long) nr | 0x100;
220        int cc = 3; /* subfunction not available */
221
222        asm volatile(
223                /* Parameter registers are ignored for "test bit" */
224                "       plo     0,0,0,0(0)\n"
225                "       ipm     %0\n"
226                "       srl     %0,28\n"
227                : "=d" (cc)
228                : "d" (r0)
229                : "cc");
230        return cc == 0;
231}
232
233static void kvm_s390_cpu_feat_init(void)
234{
235        int i;
236
237        for (i = 0; i < 256; ++i) {
238                if (plo_test_bit(i))
239                        kvm_s390_available_subfunc.plo[i >> 3] |= 0x80 >> (i & 7);
240        }
241
242        if (test_facility(28)) /* TOD-clock steering */
243                ptff(kvm_s390_available_subfunc.ptff,
244                     sizeof(kvm_s390_available_subfunc.ptff),
245                     PTFF_QAF);
246
247        if (test_facility(17)) { /* MSA */
248                __cpacf_query(CPACF_KMAC, (cpacf_mask_t *)
249                              kvm_s390_available_subfunc.kmac);
250                __cpacf_query(CPACF_KMC, (cpacf_mask_t *)
251                              kvm_s390_available_subfunc.kmc);
252                __cpacf_query(CPACF_KM, (cpacf_mask_t *)
253                              kvm_s390_available_subfunc.km);
254                __cpacf_query(CPACF_KIMD, (cpacf_mask_t *)
255                              kvm_s390_available_subfunc.kimd);
256                __cpacf_query(CPACF_KLMD, (cpacf_mask_t *)
257                              kvm_s390_available_subfunc.klmd);
258        }
259        if (test_facility(76)) /* MSA3 */
260                __cpacf_query(CPACF_PCKMO, (cpacf_mask_t *)
261                              kvm_s390_available_subfunc.pckmo);
262        if (test_facility(77)) { /* MSA4 */
263                __cpacf_query(CPACF_KMCTR, (cpacf_mask_t *)
264                              kvm_s390_available_subfunc.kmctr);
265                __cpacf_query(CPACF_KMF, (cpacf_mask_t *)
266                              kvm_s390_available_subfunc.kmf);
267                __cpacf_query(CPACF_KMO, (cpacf_mask_t *)
268                              kvm_s390_available_subfunc.kmo);
269                __cpacf_query(CPACF_PCC, (cpacf_mask_t *)
270                              kvm_s390_available_subfunc.pcc);
271        }
272        if (test_facility(57)) /* MSA5 */
273                __cpacf_query(CPACF_PPNO, (cpacf_mask_t *)
274                              kvm_s390_available_subfunc.ppno);
275
276        if (MACHINE_HAS_ESOP)
277                allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP);
278        /*
279         * We need SIE support, ESOP (PROT_READ protection for gmap_shadow),
280         * 64bit SCAO (SCA passthrough) and IDTE (for gmap_shadow unshadowing).
281         */
282        if (!sclp.has_sief2 || !MACHINE_HAS_ESOP || !sclp.has_64bscao ||
283            !test_facility(3) || !nested)
284                return;
285        allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIEF2);
286        if (sclp.has_64bscao)
287                allow_cpu_feat(KVM_S390_VM_CPU_FEAT_64BSCAO);
288        if (sclp.has_siif)
289                allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIIF);
290        if (sclp.has_gpere)
291                allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GPERE);
292        if (sclp.has_gsls)
293                allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GSLS);
294        if (sclp.has_ib)
295                allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IB);
296        if (sclp.has_cei)
297                allow_cpu_feat(KVM_S390_VM_CPU_FEAT_CEI);
298        if (sclp.has_ibs)
299                allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IBS);
300        /*
301         * KVM_S390_VM_CPU_FEAT_SKEY: Wrong shadow of PTE.I bits will make
302         * all skey handling functions read/set the skey from the PGSTE
303         * instead of the real storage key.
304         *
305         * KVM_S390_VM_CPU_FEAT_CMMA: Wrong shadow of PTE.I bits will make
306         * pages being detected as preserved although they are resident.
307         *
308         * KVM_S390_VM_CPU_FEAT_PFMFI: Wrong shadow of PTE.I bits will
309         * have the same effect as for KVM_S390_VM_CPU_FEAT_SKEY.
310         *
311         * For KVM_S390_VM_CPU_FEAT_SKEY, KVM_S390_VM_CPU_FEAT_CMMA and
312         * KVM_S390_VM_CPU_FEAT_PFMFI, all PTE.I and PGSTE bits have to be
313         * correctly shadowed. We can do that for the PGSTE but not for PTE.I.
314         *
315         * KVM_S390_VM_CPU_FEAT_SIGPIF: Wrong SCB addresses in the SCA. We
316         * cannot easily shadow the SCA because of the ipte lock.
317         */
318}
319
320int kvm_arch_init(void *opaque)
321{
322        kvm_s390_dbf = debug_register("kvm-trace", 32, 1, 7 * sizeof(long));
323        if (!kvm_s390_dbf)
324                return -ENOMEM;
325
326        if (debug_register_view(kvm_s390_dbf, &debug_sprintf_view)) {
327                debug_unregister(kvm_s390_dbf);
328                return -ENOMEM;
329        }
330
331        kvm_s390_cpu_feat_init();
332
333        /* Register floating interrupt controller interface. */
334        return kvm_register_device_ops(&kvm_flic_ops, KVM_DEV_TYPE_FLIC);
335}
336
337void kvm_arch_exit(void)
338{
339        debug_unregister(kvm_s390_dbf);
340}
341
342/* Section: device related */
343long kvm_arch_dev_ioctl(struct file *filp,
344                        unsigned int ioctl, unsigned long arg)
345{
346        if (ioctl == KVM_S390_ENABLE_SIE)
347                return s390_enable_sie();
348        return -EINVAL;
349}
350
351int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
352{
353        int r;
354
355        switch (ext) {
356        case KVM_CAP_S390_PSW:
357        case KVM_CAP_S390_GMAP:
358        case KVM_CAP_SYNC_MMU:
359#ifdef CONFIG_KVM_S390_UCONTROL
360        case KVM_CAP_S390_UCONTROL:
361#endif
362        case KVM_CAP_ASYNC_PF:
363        case KVM_CAP_SYNC_REGS:
364        case KVM_CAP_ONE_REG:
365        case KVM_CAP_ENABLE_CAP:
366        case KVM_CAP_S390_CSS_SUPPORT:
367        case KVM_CAP_IOEVENTFD:
368        case KVM_CAP_DEVICE_CTRL:
369        case KVM_CAP_ENABLE_CAP_VM:
370        case KVM_CAP_S390_IRQCHIP:
371        case KVM_CAP_VM_ATTRIBUTES:
372        case KVM_CAP_MP_STATE:
373        case KVM_CAP_S390_INJECT_IRQ:
374        case KVM_CAP_S390_USER_SIGP:
375        case KVM_CAP_S390_USER_STSI:
376        case KVM_CAP_S390_SKEYS:
377        case KVM_CAP_S390_IRQ_STATE:
378        case KVM_CAP_S390_USER_INSTR0:
379                r = 1;
380                break;
381        case KVM_CAP_S390_MEM_OP:
382                r = MEM_OP_MAX_SIZE;
383                break;
384        case KVM_CAP_NR_VCPUS:
385        case KVM_CAP_MAX_VCPUS:
386                r = KVM_S390_BSCA_CPU_SLOTS;
387                if (!kvm_s390_use_sca_entries())
388                        r = KVM_MAX_VCPUS;
389                else if (sclp.has_esca && sclp.has_64bscao)
390                        r = KVM_S390_ESCA_CPU_SLOTS;
391                break;
392        case KVM_CAP_NR_MEMSLOTS:
393                r = KVM_USER_MEM_SLOTS;
394                break;
395        case KVM_CAP_S390_COW:
396                r = MACHINE_HAS_ESOP;
397                break;
398        case KVM_CAP_S390_VECTOR_REGISTERS:
399                r = MACHINE_HAS_VX;
400                break;
401        case KVM_CAP_S390_RI:
402                r = test_facility(64);
403                break;
404        default:
405                r = 0;
406        }
407        return r;
408}
409
410static void kvm_s390_sync_dirty_log(struct kvm *kvm,
411                                        struct kvm_memory_slot *memslot)
412{
413        gfn_t cur_gfn, last_gfn;
414        unsigned long address;
415        struct gmap *gmap = kvm->arch.gmap;
416
417        /* Loop over all guest pages */
418        last_gfn = memslot->base_gfn + memslot->npages;
419        for (cur_gfn = memslot->base_gfn; cur_gfn <= last_gfn; cur_gfn++) {
420                address = gfn_to_hva_memslot(memslot, cur_gfn);
421
422                if (test_and_clear_guest_dirty(gmap->mm, address))
423                        mark_page_dirty(kvm, cur_gfn);
424                if (fatal_signal_pending(current))
425                        return;
426                cond_resched();
427        }
428}
429
430/* Section: vm related */
431static void sca_del_vcpu(struct kvm_vcpu *vcpu);
432
433/*
434 * Get (and clear) the dirty memory log for a memory slot.
435 */
436int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
437                               struct kvm_dirty_log *log)
438{
439        int r;
440        unsigned long n;
441        struct kvm_memslots *slots;
442        struct kvm_memory_slot *memslot;
443        int is_dirty = 0;
444
445        if (kvm_is_ucontrol(kvm))
446                return -EINVAL;
447
448        mutex_lock(&kvm->slots_lock);
449
450        r = -EINVAL;
451        if (log->slot >= KVM_USER_MEM_SLOTS)
452                goto out;
453
454        slots = kvm_memslots(kvm);
455        memslot = id_to_memslot(slots, log->slot);
456        r = -ENOENT;
457        if (!memslot->dirty_bitmap)
458                goto out;
459
460        kvm_s390_sync_dirty_log(kvm, memslot);
461        r = kvm_get_dirty_log(kvm, log, &is_dirty);
462        if (r)
463                goto out;
464
465        /* Clear the dirty log */
466        if (is_dirty) {
467                n = kvm_dirty_bitmap_bytes(memslot);
468                memset(memslot->dirty_bitmap, 0, n);
469        }
470        r = 0;
471out:
472        mutex_unlock(&kvm->slots_lock);
473        return r;
474}
475
476static void icpt_operexc_on_all_vcpus(struct kvm *kvm)
477{
478        unsigned int i;
479        struct kvm_vcpu *vcpu;
480
481        kvm_for_each_vcpu(i, vcpu, kvm) {
482                kvm_s390_sync_request(KVM_REQ_ICPT_OPEREXC, vcpu);
483        }
484}
485
486static int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
487{
488        int r;
489
490        if (cap->flags)
491                return -EINVAL;
492
493        switch (cap->cap) {
494        case KVM_CAP_S390_IRQCHIP:
495                VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_IRQCHIP");
496                kvm->arch.use_irqchip = 1;
497                r = 0;
498                break;
499        case KVM_CAP_S390_USER_SIGP:
500                VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_SIGP");
501                kvm->arch.user_sigp = 1;
502                r = 0;
503                break;
504        case KVM_CAP_S390_VECTOR_REGISTERS:
505                mutex_lock(&kvm->lock);
506                if (kvm->created_vcpus) {
507                        r = -EBUSY;
508                } else if (MACHINE_HAS_VX) {
509                        set_kvm_facility(kvm->arch.model.fac_mask, 129);
510                        set_kvm_facility(kvm->arch.model.fac_list, 129);
511                        r = 0;
512                } else
513                        r = -EINVAL;
514                mutex_unlock(&kvm->lock);
515                VM_EVENT(kvm, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s",
516                         r ? "(not available)" : "(success)");
517                break;
518        case KVM_CAP_S390_RI:
519                r = -EINVAL;
520                mutex_lock(&kvm->lock);
521                if (kvm->created_vcpus) {
522                        r = -EBUSY;
523                } else if (test_facility(64)) {
524                        set_kvm_facility(kvm->arch.model.fac_mask, 64);
525                        set_kvm_facility(kvm->arch.model.fac_list, 64);
526                        r = 0;
527                }
528                mutex_unlock(&kvm->lock);
529                VM_EVENT(kvm, 3, "ENABLE: CAP_S390_RI %s",
530                         r ? "(not available)" : "(success)");
531                break;
532        case KVM_CAP_S390_USER_STSI:
533                VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_STSI");
534                kvm->arch.user_stsi = 1;
535                r = 0;
536                break;
537        case KVM_CAP_S390_USER_INSTR0:
538                VM_EVENT(kvm, 3, "%s", "ENABLE: CAP_S390_USER_INSTR0");
539                kvm->arch.user_instr0 = 1;
540                icpt_operexc_on_all_vcpus(kvm);
541                r = 0;
542                break;
543        default:
544                r = -EINVAL;
545                break;
546        }
547        return r;
548}
549
550static int kvm_s390_get_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
551{
552        int ret;
553
554        switch (attr->attr) {
555        case KVM_S390_VM_MEM_LIMIT_SIZE:
556                ret = 0;
557                VM_EVENT(kvm, 3, "QUERY: max guest memory: %lu bytes",
558                         kvm->arch.mem_limit);
559                if (put_user(kvm->arch.mem_limit, (u64 __user *)attr->addr))
560                        ret = -EFAULT;
561                break;
562        default:
563                ret = -ENXIO;
564                break;
565        }
566        return ret;
567}
568
569static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attr)
570{
571        int ret;
572        unsigned int idx;
573        switch (attr->attr) {
574        case KVM_S390_VM_MEM_ENABLE_CMMA:
575                ret = -ENXIO;
576                if (!sclp.has_cmma)
577                        break;
578
579                ret = -EBUSY;
580                VM_EVENT(kvm, 3, "%s", "ENABLE: CMMA support");
581                mutex_lock(&kvm->lock);
582                if (!kvm->created_vcpus) {
583                        kvm->arch.use_cmma = 1;
584                        ret = 0;
585                }
586                mutex_unlock(&kvm->lock);
587                break;
588        case KVM_S390_VM_MEM_CLR_CMMA:
589                ret = -ENXIO;
590                if (!sclp.has_cmma)
591                        break;
592                ret = -EINVAL;
593                if (!kvm->arch.use_cmma)
594                        break;
595
596                VM_EVENT(kvm, 3, "%s", "RESET: CMMA states");
597                mutex_lock(&kvm->lock);
598                idx = srcu_read_lock(&kvm->srcu);
599                s390_reset_cmma(kvm->arch.gmap->mm);
600                srcu_read_unlock(&kvm->srcu, idx);
601                mutex_unlock(&kvm->lock);
602                ret = 0;
603                break;
604        case KVM_S390_VM_MEM_LIMIT_SIZE: {
605                unsigned long new_limit;
606
607                if (kvm_is_ucontrol(kvm))
608                        return -EINVAL;
609
610                if (get_user(new_limit, (u64 __user *)attr->addr))
611                        return -EFAULT;
612
613                if (kvm->arch.mem_limit != KVM_S390_NO_MEM_LIMIT &&
614                    new_limit > kvm->arch.mem_limit)
615                        return -E2BIG;
616
617                if (!new_limit)
618                        return -EINVAL;
619
620                /* gmap_create takes last usable address */
621                if (new_limit != KVM_S390_NO_MEM_LIMIT)
622                        new_limit -= 1;
623
624                ret = -EBUSY;
625                mutex_lock(&kvm->lock);
626                if (!kvm->created_vcpus) {
627                        /* gmap_create will round the limit up */
628                        struct gmap *new = gmap_create(current->mm, new_limit);
629
630                        if (!new) {
631                                ret = -ENOMEM;
632                        } else {
633                                gmap_remove(kvm->arch.gmap);
634                                new->private = kvm;
635                                kvm->arch.gmap = new;
636                                ret = 0;
637                        }
638                }
639                mutex_unlock(&kvm->lock);
640                VM_EVENT(kvm, 3, "SET: max guest address: %lu", new_limit);
641                VM_EVENT(kvm, 3, "New guest asce: 0x%pK",
642                         (void *) kvm->arch.gmap->asce);
643                break;
644        }
645        default:
646                ret = -ENXIO;
647                break;
648        }
649        return ret;
650}
651
652static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu);
653
654static int kvm_s390_vm_set_crypto(struct kvm *kvm, struct kvm_device_attr *attr)
655{
656        struct kvm_vcpu *vcpu;
657        int i;
658
659        if (!test_kvm_facility(kvm, 76))
660                return -EINVAL;
661
662        mutex_lock(&kvm->lock);
663        switch (attr->attr) {
664        case KVM_S390_VM_CRYPTO_ENABLE_AES_KW:
665                get_random_bytes(
666                        kvm->arch.crypto.crycb->aes_wrapping_key_mask,
667                        sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
668                kvm->arch.crypto.aes_kw = 1;
669                VM_EVENT(kvm, 3, "%s", "ENABLE: AES keywrapping support");
670                break;
671        case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW:
672                get_random_bytes(
673                        kvm->arch.crypto.crycb->dea_wrapping_key_mask,
674                        sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
675                kvm->arch.crypto.dea_kw = 1;
676                VM_EVENT(kvm, 3, "%s", "ENABLE: DEA keywrapping support");
677                break;
678        case KVM_S390_VM_CRYPTO_DISABLE_AES_KW:
679                kvm->arch.crypto.aes_kw = 0;
680                memset(kvm->arch.crypto.crycb->aes_wrapping_key_mask, 0,
681                        sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
682                VM_EVENT(kvm, 3, "%s", "DISABLE: AES keywrapping support");
683                break;
684        case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW:
685                kvm->arch.crypto.dea_kw = 0;
686                memset(kvm->arch.crypto.crycb->dea_wrapping_key_mask, 0,
687                        sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
688                VM_EVENT(kvm, 3, "%s", "DISABLE: DEA keywrapping support");
689                break;
690        default:
691                mutex_unlock(&kvm->lock);
692                return -ENXIO;
693        }
694
695        kvm_for_each_vcpu(i, vcpu, kvm) {
696                kvm_s390_vcpu_crypto_setup(vcpu);
697                exit_sie(vcpu);
698        }
699        mutex_unlock(&kvm->lock);
700        return 0;
701}
702
703static int kvm_s390_set_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
704{
705        u8 gtod_high;
706
707        if (copy_from_user(&gtod_high, (void __user *)attr->addr,
708                                           sizeof(gtod_high)))
709                return -EFAULT;
710
711        if (gtod_high != 0)
712                return -EINVAL;
713        VM_EVENT(kvm, 3, "SET: TOD extension: 0x%x", gtod_high);
714
715        return 0;
716}
717
718static int kvm_s390_set_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
719{
720        u64 gtod;
721
722        if (copy_from_user(&gtod, (void __user *)attr->addr, sizeof(gtod)))
723                return -EFAULT;
724
725        kvm_s390_set_tod_clock(kvm, gtod);
726        VM_EVENT(kvm, 3, "SET: TOD base: 0x%llx", gtod);
727        return 0;
728}
729
730static int kvm_s390_set_tod(struct kvm *kvm, struct kvm_device_attr *attr)
731{
732        int ret;
733
734        if (attr->flags)
735                return -EINVAL;
736
737        switch (attr->attr) {
738        case KVM_S390_VM_TOD_HIGH:
739                ret = kvm_s390_set_tod_high(kvm, attr);
740                break;
741        case KVM_S390_VM_TOD_LOW:
742                ret = kvm_s390_set_tod_low(kvm, attr);
743                break;
744        default:
745                ret = -ENXIO;
746                break;
747        }
748        return ret;
749}
750
751static int kvm_s390_get_tod_high(struct kvm *kvm, struct kvm_device_attr *attr)
752{
753        u8 gtod_high = 0;
754
755        if (copy_to_user((void __user *)attr->addr, &gtod_high,
756                                         sizeof(gtod_high)))
757                return -EFAULT;
758        VM_EVENT(kvm, 3, "QUERY: TOD extension: 0x%x", gtod_high);
759
760        return 0;
761}
762
763static int kvm_s390_get_tod_low(struct kvm *kvm, struct kvm_device_attr *attr)
764{
765        u64 gtod;
766
767        gtod = kvm_s390_get_tod_clock_fast(kvm);
768        if (copy_to_user((void __user *)attr->addr, &gtod, sizeof(gtod)))
769                return -EFAULT;
770        VM_EVENT(kvm, 3, "QUERY: TOD base: 0x%llx", gtod);
771
772        return 0;
773}
774
775static int kvm_s390_get_tod(struct kvm *kvm, struct kvm_device_attr *attr)
776{
777        int ret;
778
779        if (attr->flags)
780                return -EINVAL;
781
782        switch (attr->attr) {
783        case KVM_S390_VM_TOD_HIGH:
784                ret = kvm_s390_get_tod_high(kvm, attr);
785                break;
786        case KVM_S390_VM_TOD_LOW:
787                ret = kvm_s390_get_tod_low(kvm, attr);
788                break;
789        default:
790                ret = -ENXIO;
791                break;
792        }
793        return ret;
794}
795
796static int kvm_s390_set_processor(struct kvm *kvm, struct kvm_device_attr *attr)
797{
798        struct kvm_s390_vm_cpu_processor *proc;
799        u16 lowest_ibc, unblocked_ibc;
800        int ret = 0;
801
802        mutex_lock(&kvm->lock);
803        if (kvm->created_vcpus) {
804                ret = -EBUSY;
805                goto out;
806        }
807        proc = kzalloc(sizeof(*proc), GFP_KERNEL);
808        if (!proc) {
809                ret = -ENOMEM;
810                goto out;
811        }
812        if (!copy_from_user(proc, (void __user *)attr->addr,
813                            sizeof(*proc))) {
814                kvm->arch.model.cpuid = proc->cpuid;
815                lowest_ibc = sclp.ibc >> 16 & 0xfff;
816                unblocked_ibc = sclp.ibc & 0xfff;
817                if (lowest_ibc && proc->ibc) {
818                        if (proc->ibc > unblocked_ibc)
819                                kvm->arch.model.ibc = unblocked_ibc;
820                        else if (proc->ibc < lowest_ibc)
821                                kvm->arch.model.ibc = lowest_ibc;
822                        else
823                                kvm->arch.model.ibc = proc->ibc;
824                }
825                memcpy(kvm->arch.model.fac_list, proc->fac_list,
826                       S390_ARCH_FAC_LIST_SIZE_BYTE);
827        } else
828                ret = -EFAULT;
829        kfree(proc);
830out:
831        mutex_unlock(&kvm->lock);
832        return ret;
833}
834
835static int kvm_s390_set_processor_feat(struct kvm *kvm,
836                                       struct kvm_device_attr *attr)
837{
838        struct kvm_s390_vm_cpu_feat data;
839        int ret = -EBUSY;
840
841        if (copy_from_user(&data, (void __user *)attr->addr, sizeof(data)))
842                return -EFAULT;
843        if (!bitmap_subset((unsigned long *) data.feat,
844                           kvm_s390_available_cpu_feat,
845                           KVM_S390_VM_CPU_FEAT_NR_BITS))
846                return -EINVAL;
847
848        mutex_lock(&kvm->lock);
849        if (!atomic_read(&kvm->online_vcpus)) {
850                bitmap_copy(kvm->arch.cpu_feat, (unsigned long *) data.feat,
851                            KVM_S390_VM_CPU_FEAT_NR_BITS);
852                ret = 0;
853        }
854        mutex_unlock(&kvm->lock);
855        return ret;
856}
857
858static int kvm_s390_set_processor_subfunc(struct kvm *kvm,
859                                          struct kvm_device_attr *attr)
860{
861        /*
862         * Once supported by kernel + hw, we have to store the subfunctions
863         * in kvm->arch and remember that user space configured them.
864         */
865        return -ENXIO;
866}
867
868static int kvm_s390_set_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr)
869{
870        int ret = -ENXIO;
871
872        switch (attr->attr) {
873        case KVM_S390_VM_CPU_PROCESSOR:
874                ret = kvm_s390_set_processor(kvm, attr);
875                break;
876        case KVM_S390_VM_CPU_PROCESSOR_FEAT:
877                ret = kvm_s390_set_processor_feat(kvm, attr);
878                break;
879        case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC:
880                ret = kvm_s390_set_processor_subfunc(kvm, attr);
881                break;
882        }
883        return ret;
884}
885
886static int kvm_s390_get_processor(struct kvm *kvm, struct kvm_device_attr *attr)
887{
888        struct kvm_s390_vm_cpu_processor *proc;
889        int ret = 0;
890
891        proc = kzalloc(sizeof(*proc), GFP_KERNEL);
892        if (!proc) {
893                ret = -ENOMEM;
894                goto out;
895        }
896        proc->cpuid = kvm->arch.model.cpuid;
897        proc->ibc = kvm->arch.model.ibc;
898        memcpy(&proc->fac_list, kvm->arch.model.fac_list,
899               S390_ARCH_FAC_LIST_SIZE_BYTE);
900        if (copy_to_user((void __user *)attr->addr, proc, sizeof(*proc)))
901                ret = -EFAULT;
902        kfree(proc);
903out:
904        return ret;
905}
906
907static int kvm_s390_get_machine(struct kvm *kvm, struct kvm_device_attr *attr)
908{
909        struct kvm_s390_vm_cpu_machine *mach;
910        int ret = 0;
911
912        mach = kzalloc(sizeof(*mach), GFP_KERNEL);
913        if (!mach) {
914                ret = -ENOMEM;
915                goto out;
916        }
917        get_cpu_id((struct cpuid *) &mach->cpuid);
918        mach->ibc = sclp.ibc;
919        memcpy(&mach->fac_mask, kvm->arch.model.fac_mask,
920               S390_ARCH_FAC_LIST_SIZE_BYTE);
921        memcpy((unsigned long *)&mach->fac_list, S390_lowcore.stfle_fac_list,
922               sizeof(S390_lowcore.stfle_fac_list));
923        if (copy_to_user((void __user *)attr->addr, mach, sizeof(*mach)))
924                ret = -EFAULT;
925        kfree(mach);
926out:
927        return ret;
928}
929
930static int kvm_s390_get_processor_feat(struct kvm *kvm,
931                                       struct kvm_device_attr *attr)
932{
933        struct kvm_s390_vm_cpu_feat data;
934
935        bitmap_copy((unsigned long *) data.feat, kvm->arch.cpu_feat,
936                    KVM_S390_VM_CPU_FEAT_NR_BITS);
937        if (copy_to_user((void __user *)attr->addr, &data, sizeof(data)))
938                return -EFAULT;
939        return 0;
940}
941
942static int kvm_s390_get_machine_feat(struct kvm *kvm,
943                                     struct kvm_device_attr *attr)
944{
945        struct kvm_s390_vm_cpu_feat data;
946
947        bitmap_copy((unsigned long *) data.feat,
948                    kvm_s390_available_cpu_feat,
949                    KVM_S390_VM_CPU_FEAT_NR_BITS);
950        if (copy_to_user((void __user *)attr->addr, &data, sizeof(data)))
951                return -EFAULT;
952        return 0;
953}
954
955static int kvm_s390_get_processor_subfunc(struct kvm *kvm,
956                                          struct kvm_device_attr *attr)
957{
958        /*
959         * Once we can actually configure subfunctions (kernel + hw support),
960         * we have to check if they were already set by user space, if so copy
961         * them from kvm->arch.
962         */
963        return -ENXIO;
964}
965
966static int kvm_s390_get_machine_subfunc(struct kvm *kvm,
967                                        struct kvm_device_attr *attr)
968{
969        if (copy_to_user((void __user *)attr->addr, &kvm_s390_available_subfunc,
970            sizeof(struct kvm_s390_vm_cpu_subfunc)))
971                return -EFAULT;
972        return 0;
973}
974static int kvm_s390_get_cpu_model(struct kvm *kvm, struct kvm_device_attr *attr)
975{
976        int ret = -ENXIO;
977
978        switch (attr->attr) {
979        case KVM_S390_VM_CPU_PROCESSOR:
980                ret = kvm_s390_get_processor(kvm, attr);
981                break;
982        case KVM_S390_VM_CPU_MACHINE:
983                ret = kvm_s390_get_machine(kvm, attr);
984                break;
985        case KVM_S390_VM_CPU_PROCESSOR_FEAT:
986                ret = kvm_s390_get_processor_feat(kvm, attr);
987                break;
988        case KVM_S390_VM_CPU_MACHINE_FEAT:
989                ret = kvm_s390_get_machine_feat(kvm, attr);
990                break;
991        case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC:
992                ret = kvm_s390_get_processor_subfunc(kvm, attr);
993                break;
994        case KVM_S390_VM_CPU_MACHINE_SUBFUNC:
995                ret = kvm_s390_get_machine_subfunc(kvm, attr);
996                break;
997        }
998        return ret;
999}
1000
1001static int kvm_s390_vm_set_attr(struct kvm *kvm, struct kvm_device_attr *attr)
1002{
1003        int ret;
1004
1005        switch (attr->group) {
1006        case KVM_S390_VM_MEM_CTRL:
1007                ret = kvm_s390_set_mem_control(kvm, attr);
1008                break;
1009        case KVM_S390_VM_TOD:
1010                ret = kvm_s390_set_tod(kvm, attr);
1011                break;
1012        case KVM_S390_VM_CPU_MODEL:
1013                ret = kvm_s390_set_cpu_model(kvm, attr);
1014                break;
1015        case KVM_S390_VM_CRYPTO:
1016                ret = kvm_s390_vm_set_crypto(kvm, attr);
1017                break;
1018        default:
1019                ret = -ENXIO;
1020                break;
1021        }
1022
1023        return ret;
1024}
1025
1026static int kvm_s390_vm_get_attr(struct kvm *kvm, struct kvm_device_attr *attr)
1027{
1028        int ret;
1029
1030        switch (attr->group) {
1031        case KVM_S390_VM_MEM_CTRL:
1032                ret = kvm_s390_get_mem_control(kvm, attr);
1033                break;
1034        case KVM_S390_VM_TOD:
1035                ret = kvm_s390_get_tod(kvm, attr);
1036                break;
1037        case KVM_S390_VM_CPU_MODEL:
1038                ret = kvm_s390_get_cpu_model(kvm, attr);
1039                break;
1040        default:
1041                ret = -ENXIO;
1042                break;
1043        }
1044
1045        return ret;
1046}
1047
1048static int kvm_s390_vm_has_attr(struct kvm *kvm, struct kvm_device_attr *attr)
1049{
1050        int ret;
1051
1052        switch (attr->group) {
1053        case KVM_S390_VM_MEM_CTRL:
1054                switch (attr->attr) {
1055                case KVM_S390_VM_MEM_ENABLE_CMMA:
1056                case KVM_S390_VM_MEM_CLR_CMMA:
1057                        ret = sclp.has_cmma ? 0 : -ENXIO;
1058                        break;
1059                case KVM_S390_VM_MEM_LIMIT_SIZE:
1060                        ret = 0;
1061                        break;
1062                default:
1063                        ret = -ENXIO;
1064                        break;
1065                }
1066                break;
1067        case KVM_S390_VM_TOD:
1068                switch (attr->attr) {
1069                case KVM_S390_VM_TOD_LOW:
1070                case KVM_S390_VM_TOD_HIGH:
1071                        ret = 0;
1072                        break;
1073                default:
1074                        ret = -ENXIO;
1075                        break;
1076                }
1077                break;
1078        case KVM_S390_VM_CPU_MODEL:
1079                switch (attr->attr) {
1080                case KVM_S390_VM_CPU_PROCESSOR:
1081                case KVM_S390_VM_CPU_MACHINE:
1082                case KVM_S390_VM_CPU_PROCESSOR_FEAT:
1083                case KVM_S390_VM_CPU_MACHINE_FEAT:
1084                case KVM_S390_VM_CPU_MACHINE_SUBFUNC:
1085                        ret = 0;
1086                        break;
1087                /* configuring subfunctions is not supported yet */
1088                case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC:
1089                default:
1090                        ret = -ENXIO;
1091                        break;
1092                }
1093                break;
1094        case KVM_S390_VM_CRYPTO:
1095                switch (attr->attr) {
1096                case KVM_S390_VM_CRYPTO_ENABLE_AES_KW:
1097                case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW:
1098                case KVM_S390_VM_CRYPTO_DISABLE_AES_KW:
1099                case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW:
1100                        ret = 0;
1101                        break;
1102                default:
1103                        ret = -ENXIO;
1104                        break;
1105                }
1106                break;
1107        default:
1108                ret = -ENXIO;
1109                break;
1110        }
1111
1112        return ret;
1113}
1114
1115static long kvm_s390_get_skeys(struct kvm *kvm, struct kvm_s390_skeys *args)
1116{
1117        uint8_t *keys;
1118        uint64_t hva;
1119        int i, r = 0;
1120
1121        if (args->flags != 0)
1122                return -EINVAL;
1123
1124        /* Is this guest using storage keys? */
1125        if (!mm_use_skey(current->mm))
1126                return KVM_S390_GET_SKEYS_NONE;
1127
1128        /* Enforce sane limit on memory allocation */
1129        if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX)
1130                return -EINVAL;
1131
1132        keys = kmalloc_array(args->count, sizeof(uint8_t),
1133                             GFP_KERNEL | __GFP_NOWARN);
1134        if (!keys)
1135                keys = vmalloc(sizeof(uint8_t) * args->count);
1136        if (!keys)
1137                return -ENOMEM;
1138
1139        down_read(&current->mm->mmap_sem);
1140        for (i = 0; i < args->count; i++) {
1141                hva = gfn_to_hva(kvm, args->start_gfn + i);
1142                if (kvm_is_error_hva(hva)) {
1143                        r = -EFAULT;
1144                        break;
1145                }
1146
1147                r = get_guest_storage_key(current->mm, hva, &keys[i]);
1148                if (r)
1149                        break;
1150        }
1151        up_read(&current->mm->mmap_sem);
1152
1153        if (!r) {
1154                r = copy_to_user((uint8_t __user *)args->skeydata_addr, keys,
1155                                 sizeof(uint8_t) * args->count);
1156                if (r)
1157                        r = -EFAULT;
1158        }
1159
1160        kvfree(keys);
1161        return r;
1162}
1163
1164static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args)
1165{
1166        uint8_t *keys;
1167        uint64_t hva;
1168        int i, r = 0;
1169
1170        if (args->flags != 0)
1171                return -EINVAL;
1172
1173        /* Enforce sane limit on memory allocation */
1174        if (args->count < 1 || args->count > KVM_S390_SKEYS_MAX)
1175                return -EINVAL;
1176
1177        keys = kmalloc_array(args->count, sizeof(uint8_t),
1178                             GFP_KERNEL | __GFP_NOWARN);
1179        if (!keys)
1180                keys = vmalloc(sizeof(uint8_t) * args->count);
1181        if (!keys)
1182                return -ENOMEM;
1183
1184        r = copy_from_user(keys, (uint8_t __user *)args->skeydata_addr,
1185                           sizeof(uint8_t) * args->count);
1186        if (r) {
1187                r = -EFAULT;
1188                goto out;
1189        }
1190
1191        /* Enable storage key handling for the guest */
1192        r = s390_enable_skey();
1193        if (r)
1194                goto out;
1195
1196        down_read(&current->mm->mmap_sem);
1197        for (i = 0; i < args->count; i++) {
1198                hva = gfn_to_hva(kvm, args->start_gfn + i);
1199                if (kvm_is_error_hva(hva)) {
1200                        r = -EFAULT;
1201                        break;
1202                }
1203
1204                /* Lowest order bit is reserved */
1205                if (keys[i] & 0x01) {
1206                        r = -EINVAL;
1207                        break;
1208                }
1209
1210                r = set_guest_storage_key(current->mm, hva, keys[i], 0);
1211                if (r)
1212                        break;
1213        }
1214        up_read(&current->mm->mmap_sem);
1215out:
1216        kvfree(keys);
1217        return r;
1218}
1219
1220long kvm_arch_vm_ioctl(struct file *filp,
1221                       unsigned int ioctl, unsigned long arg)
1222{
1223        struct kvm *kvm = filp->private_data;
1224        void __user *argp = (void __user *)arg;
1225        struct kvm_device_attr attr;
1226        int r;
1227
1228        switch (ioctl) {
1229        case KVM_S390_INTERRUPT: {
1230                struct kvm_s390_interrupt s390int;
1231
1232                r = -EFAULT;
1233                if (copy_from_user(&s390int, argp, sizeof(s390int)))
1234                        break;
1235                r = kvm_s390_inject_vm(kvm, &s390int);
1236                break;
1237        }
1238        case KVM_ENABLE_CAP: {
1239                struct kvm_enable_cap cap;
1240                r = -EFAULT;
1241                if (copy_from_user(&cap, argp, sizeof(cap)))
1242                        break;
1243                r = kvm_vm_ioctl_enable_cap(kvm, &cap);
1244                break;
1245        }
1246        case KVM_CREATE_IRQCHIP: {
1247                struct kvm_irq_routing_entry routing;
1248
1249                r = -EINVAL;
1250                if (kvm->arch.use_irqchip) {
1251                        /* Set up dummy routing. */
1252                        memset(&routing, 0, sizeof(routing));
1253                        r = kvm_set_irq_routing(kvm, &routing, 0, 0);
1254                }
1255                break;
1256        }
1257        case KVM_SET_DEVICE_ATTR: {
1258                r = -EFAULT;
1259                if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
1260                        break;
1261                r = kvm_s390_vm_set_attr(kvm, &attr);
1262                break;
1263        }
1264        case KVM_GET_DEVICE_ATTR: {
1265                r = -EFAULT;
1266                if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
1267                        break;
1268                r = kvm_s390_vm_get_attr(kvm, &attr);
1269                break;
1270        }
1271        case KVM_HAS_DEVICE_ATTR: {
1272                r = -EFAULT;
1273                if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
1274                        break;
1275                r = kvm_s390_vm_has_attr(kvm, &attr);
1276                break;
1277        }
1278        case KVM_S390_GET_SKEYS: {
1279                struct kvm_s390_skeys args;
1280
1281                r = -EFAULT;
1282                if (copy_from_user(&args, argp,
1283                                   sizeof(struct kvm_s390_skeys)))
1284                        break;
1285                r = kvm_s390_get_skeys(kvm, &args);
1286                break;
1287        }
1288        case KVM_S390_SET_SKEYS: {
1289                struct kvm_s390_skeys args;
1290
1291                r = -EFAULT;
1292                if (copy_from_user(&args, argp,
1293                                   sizeof(struct kvm_s390_skeys)))
1294                        break;
1295                r = kvm_s390_set_skeys(kvm, &args);
1296                break;
1297        }
1298        default:
1299                r = -ENOTTY;
1300        }
1301
1302        return r;
1303}
1304
1305static int kvm_s390_query_ap_config(u8 *config)
1306{
1307        u32 fcn_code = 0x04000000UL;
1308        u32 cc = 0;
1309
1310        memset(config, 0, 128);
1311        asm volatile(
1312                "lgr 0,%1\n"
1313                "lgr 2,%2\n"
1314                ".long 0xb2af0000\n"            /* PQAP(QCI) */
1315                "0: ipm %0\n"
1316                "srl %0,28\n"
1317                "1:\n"
1318                EX_TABLE(0b, 1b)
1319                : "+r" (cc)
1320                : "r" (fcn_code), "r" (config)
1321                : "cc", "0", "2", "memory"
1322        );
1323
1324        return cc;
1325}
1326
1327static int kvm_s390_apxa_installed(void)
1328{
1329        u8 config[128];
1330        int cc;
1331
1332        if (test_facility(12)) {
1333                cc = kvm_s390_query_ap_config(config);
1334
1335                if (cc)
1336                        pr_err("PQAP(QCI) failed with cc=%d", cc);
1337                else
1338                        return config[0] & 0x40;
1339        }
1340
1341        return 0;
1342}
1343
1344static void kvm_s390_set_crycb_format(struct kvm *kvm)
1345{
1346        kvm->arch.crypto.crycbd = (__u32)(unsigned long) kvm->arch.crypto.crycb;
1347
1348        if (kvm_s390_apxa_installed())
1349                kvm->arch.crypto.crycbd |= CRYCB_FORMAT2;
1350        else
1351                kvm->arch.crypto.crycbd |= CRYCB_FORMAT1;
1352}
1353
1354static u64 kvm_s390_get_initial_cpuid(void)
1355{
1356        struct cpuid cpuid;
1357
1358        get_cpu_id(&cpuid);
1359        cpuid.version = 0xff;
1360        return *((u64 *) &cpuid);
1361}
1362
1363static void kvm_s390_crypto_init(struct kvm *kvm)
1364{
1365        if (!test_kvm_facility(kvm, 76))
1366                return;
1367
1368        kvm->arch.crypto.crycb = &kvm->arch.sie_page2->crycb;
1369        kvm_s390_set_crycb_format(kvm);
1370
1371        /* Enable AES/DEA protected key functions by default */
1372        kvm->arch.crypto.aes_kw = 1;
1373        kvm->arch.crypto.dea_kw = 1;
1374        get_random_bytes(kvm->arch.crypto.crycb->aes_wrapping_key_mask,
1375                         sizeof(kvm->arch.crypto.crycb->aes_wrapping_key_mask));
1376        get_random_bytes(kvm->arch.crypto.crycb->dea_wrapping_key_mask,
1377                         sizeof(kvm->arch.crypto.crycb->dea_wrapping_key_mask));
1378}
1379
1380static void sca_dispose(struct kvm *kvm)
1381{
1382        if (kvm->arch.use_esca)
1383                free_pages_exact(kvm->arch.sca, sizeof(struct esca_block));
1384        else
1385                free_page((unsigned long)(kvm->arch.sca));
1386        kvm->arch.sca = NULL;
1387}
1388
1389int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
1390{
1391        gfp_t alloc_flags = GFP_KERNEL;
1392        int i, rc;
1393        char debug_name[16];
1394        static unsigned long sca_offset;
1395
1396        rc = -EINVAL;
1397#ifdef CONFIG_KVM_S390_UCONTROL
1398        if (type & ~KVM_VM_S390_UCONTROL)
1399                goto out_err;
1400        if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
1401                goto out_err;
1402#else
1403        if (type)
1404                goto out_err;
1405#endif
1406
1407        rc = s390_enable_sie();
1408        if (rc)
1409                goto out_err;
1410
1411        rc = -ENOMEM;
1412
1413        ratelimit_state_init(&kvm->arch.sthyi_limit, 5 * HZ, 500);
1414
1415        kvm->arch.use_esca = 0; /* start with basic SCA */
1416        if (!sclp.has_64bscao)
1417                alloc_flags |= GFP_DMA;
1418        rwlock_init(&kvm->arch.sca_lock);
1419        kvm->arch.sca = (struct bsca_block *) get_zeroed_page(alloc_flags);
1420        if (!kvm->arch.sca)
1421                goto out_err;
1422        spin_lock(&kvm_lock);
1423        sca_offset += 16;
1424        if (sca_offset + sizeof(struct bsca_block) > PAGE_SIZE)
1425                sca_offset = 0;
1426        kvm->arch.sca = (struct bsca_block *)
1427                        ((char *) kvm->arch.sca + sca_offset);
1428        spin_unlock(&kvm_lock);
1429
1430        sprintf(debug_name, "kvm-%u", current->pid);
1431
1432        kvm->arch.dbf = debug_register(debug_name, 32, 1, 7 * sizeof(long));
1433        if (!kvm->arch.dbf)
1434                goto out_err;
1435
1436        kvm->arch.sie_page2 =
1437             (struct sie_page2 *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
1438        if (!kvm->arch.sie_page2)
1439                goto out_err;
1440
1441        /* Populate the facility mask initially. */
1442        memcpy(kvm->arch.model.fac_mask, S390_lowcore.stfle_fac_list,
1443               sizeof(S390_lowcore.stfle_fac_list));
1444        for (i = 0; i < S390_ARCH_FAC_LIST_SIZE_U64; i++) {
1445                if (i < kvm_s390_fac_list_mask_size())
1446                        kvm->arch.model.fac_mask[i] &= kvm_s390_fac_list_mask[i];
1447                else
1448                        kvm->arch.model.fac_mask[i] = 0UL;
1449        }
1450
1451        /* Populate the facility list initially. */
1452        kvm->arch.model.fac_list = kvm->arch.sie_page2->fac_list;
1453        memcpy(kvm->arch.model.fac_list, kvm->arch.model.fac_mask,
1454               S390_ARCH_FAC_LIST_SIZE_BYTE);
1455
1456        set_kvm_facility(kvm->arch.model.fac_mask, 74);
1457        set_kvm_facility(kvm->arch.model.fac_list, 74);
1458
1459        kvm->arch.model.cpuid = kvm_s390_get_initial_cpuid();
1460        kvm->arch.model.ibc = sclp.ibc & 0x0fff;
1461
1462        kvm_s390_crypto_init(kvm);
1463
1464        spin_lock_init(&kvm->arch.float_int.lock);
1465        for (i = 0; i < FIRQ_LIST_COUNT; i++)
1466                INIT_LIST_HEAD(&kvm->arch.float_int.lists[i]);
1467        init_waitqueue_head(&kvm->arch.ipte_wq);
1468        mutex_init(&kvm->arch.ipte_mutex);
1469
1470        debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
1471        VM_EVENT(kvm, 3, "vm created with type %lu", type);
1472
1473        if (type & KVM_VM_S390_UCONTROL) {
1474                kvm->arch.gmap = NULL;
1475                kvm->arch.mem_limit = KVM_S390_NO_MEM_LIMIT;
1476        } else {
1477                if (sclp.hamax == U64_MAX)
1478                        kvm->arch.mem_limit = TASK_MAX_SIZE;
1479                else
1480                        kvm->arch.mem_limit = min_t(unsigned long, TASK_MAX_SIZE,
1481                                                    sclp.hamax + 1);
1482                kvm->arch.gmap = gmap_create(current->mm, kvm->arch.mem_limit - 1);
1483                if (!kvm->arch.gmap)
1484                        goto out_err;
1485                kvm->arch.gmap->private = kvm;
1486                kvm->arch.gmap->pfault_enabled = 0;
1487        }
1488
1489        kvm->arch.css_support = 0;
1490        kvm->arch.use_irqchip = 0;
1491        kvm->arch.epoch = 0;
1492
1493        spin_lock_init(&kvm->arch.start_stop_lock);
1494        kvm_s390_vsie_init(kvm);
1495        KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm, current->pid);
1496
1497        return 0;
1498out_err:
1499        free_page((unsigned long)kvm->arch.sie_page2);
1500        debug_unregister(kvm->arch.dbf);
1501        sca_dispose(kvm);
1502        KVM_EVENT(3, "creation of vm failed: %d", rc);
1503        return rc;
1504}
1505
1506bool kvm_arch_has_vcpu_debugfs(void)
1507{
1508        return false;
1509}
1510
1511int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
1512{
1513        return 0;
1514}
1515
1516void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
1517{
1518        VCPU_EVENT(vcpu, 3, "%s", "free cpu");
1519        trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
1520        kvm_s390_clear_local_irqs(vcpu);
1521        kvm_clear_async_pf_completion_queue(vcpu);
1522        if (!kvm_is_ucontrol(vcpu->kvm))
1523                sca_del_vcpu(vcpu);
1524
1525        if (kvm_is_ucontrol(vcpu->kvm))
1526                gmap_remove(vcpu->arch.gmap);
1527
1528        if (vcpu->kvm->arch.use_cmma)
1529                kvm_s390_vcpu_unsetup_cmma(vcpu);
1530        free_page((unsigned long)(vcpu->arch.sie_block));
1531
1532        kvm_vcpu_uninit(vcpu);
1533        kmem_cache_free(kvm_vcpu_cache, vcpu);
1534}
1535
1536static void kvm_free_vcpus(struct kvm *kvm)
1537{
1538        unsigned int i;
1539        struct kvm_vcpu *vcpu;
1540
1541        kvm_for_each_vcpu(i, vcpu, kvm)
1542                kvm_arch_vcpu_destroy(vcpu);
1543
1544        mutex_lock(&kvm->lock);
1545        for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
1546                kvm->vcpus[i] = NULL;
1547
1548        atomic_set(&kvm->online_vcpus, 0);
1549        mutex_unlock(&kvm->lock);
1550}
1551
1552void kvm_arch_destroy_vm(struct kvm *kvm)
1553{
1554        kvm_free_vcpus(kvm);
1555        sca_dispose(kvm);
1556        debug_unregister(kvm->arch.dbf);
1557        free_page((unsigned long)kvm->arch.sie_page2);
1558        if (!kvm_is_ucontrol(kvm))
1559                gmap_remove(kvm->arch.gmap);
1560        kvm_s390_destroy_adapters(kvm);
1561        kvm_s390_clear_float_irqs(kvm);
1562        kvm_s390_vsie_destroy(kvm);
1563        KVM_EVENT(3, "vm 0x%pK destroyed", kvm);
1564}
1565
1566/* Section: vcpu related */
1567static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu *vcpu)
1568{
1569        vcpu->arch.gmap = gmap_create(current->mm, -1UL);
1570        if (!vcpu->arch.gmap)
1571                return -ENOMEM;
1572        vcpu->arch.gmap->private = vcpu->kvm;
1573
1574        return 0;
1575}
1576
1577static void sca_del_vcpu(struct kvm_vcpu *vcpu)
1578{
1579        if (!kvm_s390_use_sca_entries())
1580                return;
1581        read_lock(&vcpu->kvm->arch.sca_lock);
1582        if (vcpu->kvm->arch.use_esca) {
1583                struct esca_block *sca = vcpu->kvm->arch.sca;
1584
1585                clear_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn);
1586                sca->cpu[vcpu->vcpu_id].sda = 0;
1587        } else {
1588                struct bsca_block *sca = vcpu->kvm->arch.sca;
1589
1590                clear_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn);
1591                sca->cpu[vcpu->vcpu_id].sda = 0;
1592        }
1593        read_unlock(&vcpu->kvm->arch.sca_lock);
1594}
1595
1596static void sca_add_vcpu(struct kvm_vcpu *vcpu)
1597{
1598        if (!kvm_s390_use_sca_entries()) {
1599                struct bsca_block *sca = vcpu->kvm->arch.sca;
1600
1601                /* we still need the basic sca for the ipte control */
1602                vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32);
1603                vcpu->arch.sie_block->scaol = (__u32)(__u64)sca;
1604        }
1605        read_lock(&vcpu->kvm->arch.sca_lock);
1606        if (vcpu->kvm->arch.use_esca) {
1607                struct esca_block *sca = vcpu->kvm->arch.sca;
1608
1609                sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block;
1610                vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32);
1611                vcpu->arch.sie_block->scaol = (__u32)(__u64)sca & ~0x3fU;
1612                vcpu->arch.sie_block->ecb2 |= 0x04U;
1613                set_bit_inv(vcpu->vcpu_id, (unsigned long *) sca->mcn);
1614        } else {
1615                struct bsca_block *sca = vcpu->kvm->arch.sca;
1616
1617                sca->cpu[vcpu->vcpu_id].sda = (__u64) vcpu->arch.sie_block;
1618                vcpu->arch.sie_block->scaoh = (__u32)(((__u64)sca) >> 32);
1619                vcpu->arch.sie_block->scaol = (__u32)(__u64)sca;
1620                set_bit_inv(vcpu->vcpu_id, (unsigned long *) &sca->mcn);
1621        }
1622        read_unlock(&vcpu->kvm->arch.sca_lock);
1623}
1624
1625/* Basic SCA to Extended SCA data copy routines */
1626static inline void sca_copy_entry(struct esca_entry *d, struct bsca_entry *s)
1627{
1628        d->sda = s->sda;
1629        d->sigp_ctrl.c = s->sigp_ctrl.c;
1630        d->sigp_ctrl.scn = s->sigp_ctrl.scn;
1631}
1632
1633static void sca_copy_b_to_e(struct esca_block *d, struct bsca_block *s)
1634{
1635        int i;
1636
1637        d->ipte_control = s->ipte_control;
1638        d->mcn[0] = s->mcn;
1639        for (i = 0; i < KVM_S390_BSCA_CPU_SLOTS; i++)
1640                sca_copy_entry(&d->cpu[i], &s->cpu[i]);
1641}
1642
1643static int sca_switch_to_extended(struct kvm *kvm)
1644{
1645        struct bsca_block *old_sca = kvm->arch.sca;
1646        struct esca_block *new_sca;
1647        struct kvm_vcpu *vcpu;
1648        unsigned int vcpu_idx;
1649        u32 scaol, scaoh;
1650
1651        new_sca = alloc_pages_exact(sizeof(*new_sca), GFP_KERNEL|__GFP_ZERO);
1652        if (!new_sca)
1653                return -ENOMEM;
1654
1655        scaoh = (u32)((u64)(new_sca) >> 32);
1656        scaol = (u32)(u64)(new_sca) & ~0x3fU;
1657
1658        kvm_s390_vcpu_block_all(kvm);
1659        write_lock(&kvm->arch.sca_lock);
1660
1661        sca_copy_b_to_e(new_sca, old_sca);
1662
1663        kvm_for_each_vcpu(vcpu_idx, vcpu, kvm) {
1664                vcpu->arch.sie_block->scaoh = scaoh;
1665                vcpu->arch.sie_block->scaol = scaol;
1666                vcpu->arch.sie_block->ecb2 |= 0x04U;
1667        }
1668        kvm->arch.sca = new_sca;
1669        kvm->arch.use_esca = 1;
1670
1671        write_unlock(&kvm->arch.sca_lock);
1672        kvm_s390_vcpu_unblock_all(kvm);
1673
1674        free_page((unsigned long)old_sca);
1675
1676        VM_EVENT(kvm, 2, "Switched to ESCA (0x%pK -> 0x%pK)",
1677                 old_sca, kvm->arch.sca);
1678        return 0;
1679}
1680
1681static int sca_can_add_vcpu(struct kvm *kvm, unsigned int id)
1682{
1683        int rc;
1684
1685        if (!kvm_s390_use_sca_entries()) {
1686                if (id < KVM_MAX_VCPUS)
1687                        return true;
1688                return false;
1689        }
1690        if (id < KVM_S390_BSCA_CPU_SLOTS)
1691                return true;
1692        if (!sclp.has_esca || !sclp.has_64bscao)
1693                return false;
1694
1695        mutex_lock(&kvm->lock);
1696        rc = kvm->arch.use_esca ? 0 : sca_switch_to_extended(kvm);
1697        mutex_unlock(&kvm->lock);
1698
1699        return rc == 0 && id < KVM_S390_ESCA_CPU_SLOTS;
1700}
1701
1702int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
1703{
1704        vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
1705        kvm_clear_async_pf_completion_queue(vcpu);
1706        vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
1707                                    KVM_SYNC_GPRS |
1708                                    KVM_SYNC_ACRS |
1709                                    KVM_SYNC_CRS |
1710                                    KVM_SYNC_ARCH0 |
1711                                    KVM_SYNC_PFAULT;
1712        kvm_s390_set_prefix(vcpu, 0);
1713        if (test_kvm_facility(vcpu->kvm, 64))
1714                vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB;
1715        /* fprs can be synchronized via vrs, even if the guest has no vx. With
1716         * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format.
1717         */
1718        if (MACHINE_HAS_VX)
1719                vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS;
1720        else
1721                vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS;
1722
1723        if (kvm_is_ucontrol(vcpu->kvm))
1724                return __kvm_ucontrol_vcpu_init(vcpu);
1725
1726        return 0;
1727}
1728
1729/* needs disabled preemption to protect from TOD sync and vcpu_load/put */
1730static void __start_cpu_timer_accounting(struct kvm_vcpu *vcpu)
1731{
1732        WARN_ON_ONCE(vcpu->arch.cputm_start != 0);
1733        raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount);
1734        vcpu->arch.cputm_start = get_tod_clock_fast();
1735        raw_write_seqcount_end(&vcpu->arch.cputm_seqcount);
1736}
1737
1738/* needs disabled preemption to protect from TOD sync and vcpu_load/put */
1739static void __stop_cpu_timer_accounting(struct kvm_vcpu *vcpu)
1740{
1741        WARN_ON_ONCE(vcpu->arch.cputm_start == 0);
1742        raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount);
1743        vcpu->arch.sie_block->cputm -= get_tod_clock_fast() - vcpu->arch.cputm_start;
1744        vcpu->arch.cputm_start = 0;
1745        raw_write_seqcount_end(&vcpu->arch.cputm_seqcount);
1746}
1747
1748/* needs disabled preemption to protect from TOD sync and vcpu_load/put */
1749static void __enable_cpu_timer_accounting(struct kvm_vcpu *vcpu)
1750{
1751        WARN_ON_ONCE(vcpu->arch.cputm_enabled);
1752        vcpu->arch.cputm_enabled = true;
1753        __start_cpu_timer_accounting(vcpu);
1754}
1755
1756/* needs disabled preemption to protect from TOD sync and vcpu_load/put */
1757static void __disable_cpu_timer_accounting(struct kvm_vcpu *vcpu)
1758{
1759        WARN_ON_ONCE(!vcpu->arch.cputm_enabled);
1760        __stop_cpu_timer_accounting(vcpu);
1761        vcpu->arch.cputm_enabled = false;
1762}
1763
1764static void enable_cpu_timer_accounting(struct kvm_vcpu *vcpu)
1765{
1766        preempt_disable(); /* protect from TOD sync and vcpu_load/put */
1767        __enable_cpu_timer_accounting(vcpu);
1768        preempt_enable();
1769}
1770
1771static void disable_cpu_timer_accounting(struct kvm_vcpu *vcpu)
1772{
1773        preempt_disable(); /* protect from TOD sync and vcpu_load/put */
1774        __disable_cpu_timer_accounting(vcpu);
1775        preempt_enable();
1776}
1777
1778/* set the cpu timer - may only be called from the VCPU thread itself */
1779void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm)
1780{
1781        preempt_disable(); /* protect from TOD sync and vcpu_load/put */
1782        raw_write_seqcount_begin(&vcpu->arch.cputm_seqcount);
1783        if (vcpu->arch.cputm_enabled)
1784                vcpu->arch.cputm_start = get_tod_clock_fast();
1785        vcpu->arch.sie_block->cputm = cputm;
1786        raw_write_seqcount_end(&vcpu->arch.cputm_seqcount);
1787        preempt_enable();
1788}
1789
1790/* update and get the cpu timer - can also be called from other VCPU threads */
1791__u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu)
1792{
1793        unsigned int seq;
1794        __u64 value;
1795
1796        if (unlikely(!vcpu->arch.cputm_enabled))
1797                return vcpu->arch.sie_block->cputm;
1798
1799        preempt_disable(); /* protect from TOD sync and vcpu_load/put */
1800        do {
1801                seq = raw_read_seqcount(&vcpu->arch.cputm_seqcount);
1802                /*
1803                 * If the writer would ever execute a read in the critical
1804                 * section, e.g. in irq context, we have a deadlock.
1805                 */
1806                WARN_ON_ONCE((seq & 1) && smp_processor_id() == vcpu->cpu);
1807                value = vcpu->arch.sie_block->cputm;
1808                /* if cputm_start is 0, accounting is being started/stopped */
1809                if (likely(vcpu->arch.cputm_start))
1810                        value -= get_tod_clock_fast() - vcpu->arch.cputm_start;
1811        } while (read_seqcount_retry(&vcpu->arch.cputm_seqcount, seq & ~1));
1812        preempt_enable();
1813        return value;
1814}
1815
1816void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
1817{
1818        /* Save host register state */
1819        save_fpu_regs();
1820        vcpu->arch.host_fpregs.fpc = current->thread.fpu.fpc;
1821        vcpu->arch.host_fpregs.regs = current->thread.fpu.regs;
1822
1823        if (MACHINE_HAS_VX)
1824                current->thread.fpu.regs = vcpu->run->s.regs.vrs;
1825        else
1826                current->thread.fpu.regs = vcpu->run->s.regs.fprs;
1827        current->thread.fpu.fpc = vcpu->run->s.regs.fpc;
1828        if (test_fp_ctl(current->thread.fpu.fpc))
1829                /* User space provided an invalid FPC, let's clear it */
1830                current->thread.fpu.fpc = 0;
1831
1832        save_access_regs(vcpu->arch.host_acrs);
1833        restore_access_regs(vcpu->run->s.regs.acrs);
1834        gmap_enable(vcpu->arch.enabled_gmap);
1835        atomic_or(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
1836        if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu))
1837                __start_cpu_timer_accounting(vcpu);
1838        vcpu->cpu = cpu;
1839}
1840
1841void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
1842{
1843        vcpu->cpu = -1;
1844        if (vcpu->arch.cputm_enabled && !is_vcpu_idle(vcpu))
1845                __stop_cpu_timer_accounting(vcpu);
1846        atomic_andnot(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
1847        vcpu->arch.enabled_gmap = gmap_get_enabled();
1848        gmap_disable(vcpu->arch.enabled_gmap);
1849
1850        /* Save guest register state */
1851        save_fpu_regs();
1852        vcpu->run->s.regs.fpc = current->thread.fpu.fpc;
1853
1854        /* Restore host register state */
1855        current->thread.fpu.fpc = vcpu->arch.host_fpregs.fpc;
1856        current->thread.fpu.regs = vcpu->arch.host_fpregs.regs;
1857
1858        save_access_regs(vcpu->run->s.regs.acrs);
1859        restore_access_regs(vcpu->arch.host_acrs);
1860}
1861
1862static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
1863{
1864        /* this equals initial cpu reset in pop, but we don't switch to ESA */
1865        vcpu->arch.sie_block->gpsw.mask = 0UL;
1866        vcpu->arch.sie_block->gpsw.addr = 0UL;
1867        kvm_s390_set_prefix(vcpu, 0);
1868        kvm_s390_set_cpu_timer(vcpu, 0);
1869        vcpu->arch.sie_block->ckc       = 0UL;
1870        vcpu->arch.sie_block->todpr     = 0;
1871        memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
1872        vcpu->arch.sie_block->gcr[0]  = 0xE0UL;
1873        vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
1874        /* make sure the new fpc will be lazily loaded */
1875        save_fpu_regs();
1876        current->thread.fpu.fpc = 0;
1877        vcpu->arch.sie_block->gbea = 1;
1878        vcpu->arch.sie_block->pp = 0;
1879        vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
1880        kvm_clear_async_pf_completion_queue(vcpu);
1881        if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm))
1882                kvm_s390_vcpu_stop(vcpu);
1883        kvm_s390_clear_local_irqs(vcpu);
1884}
1885
1886void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
1887{
1888        mutex_lock(&vcpu->kvm->lock);
1889        preempt_disable();
1890        vcpu->arch.sie_block->epoch = vcpu->kvm->arch.epoch;
1891        preempt_enable();
1892        mutex_unlock(&vcpu->kvm->lock);
1893        if (!kvm_is_ucontrol(vcpu->kvm)) {
1894                vcpu->arch.gmap = vcpu->kvm->arch.gmap;
1895                sca_add_vcpu(vcpu);
1896        }
1897        if (test_kvm_facility(vcpu->kvm, 74) || vcpu->kvm->arch.user_instr0)
1898                vcpu->arch.sie_block->ictl |= ICTL_OPEREXC;
1899        /* make vcpu_load load the right gmap on the first trigger */
1900        vcpu->arch.enabled_gmap = vcpu->arch.gmap;
1901}
1902
1903static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu *vcpu)
1904{
1905        if (!test_kvm_facility(vcpu->kvm, 76))
1906                return;
1907
1908        vcpu->arch.sie_block->ecb3 &= ~(ECB3_AES | ECB3_DEA);
1909
1910        if (vcpu->kvm->arch.crypto.aes_kw)
1911                vcpu->arch.sie_block->ecb3 |= ECB3_AES;
1912        if (vcpu->kvm->arch.crypto.dea_kw)
1913                vcpu->arch.sie_block->ecb3 |= ECB3_DEA;
1914
1915        vcpu->arch.sie_block->crycbd = vcpu->kvm->arch.crypto.crycbd;
1916}
1917
1918void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu)
1919{
1920        free_page(vcpu->arch.sie_block->cbrlo);
1921        vcpu->arch.sie_block->cbrlo = 0;
1922}
1923
1924int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu)
1925{
1926        vcpu->arch.sie_block->cbrlo = get_zeroed_page(GFP_KERNEL);
1927        if (!vcpu->arch.sie_block->cbrlo)
1928                return -ENOMEM;
1929
1930        vcpu->arch.sie_block->ecb2 |= 0x80;
1931        vcpu->arch.sie_block->ecb2 &= ~0x08;
1932        return 0;
1933}
1934
1935static void kvm_s390_vcpu_setup_model(struct kvm_vcpu *vcpu)
1936{
1937        struct kvm_s390_cpu_model *model = &vcpu->kvm->arch.model;
1938
1939        vcpu->arch.sie_block->ibc = model->ibc;
1940        if (test_kvm_facility(vcpu->kvm, 7))
1941                vcpu->arch.sie_block->fac = (u32)(u64) model->fac_list;
1942}
1943
1944int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
1945{
1946        int rc = 0;
1947
1948        atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
1949                                                    CPUSTAT_SM |
1950                                                    CPUSTAT_STOPPED);
1951
1952        if (test_kvm_facility(vcpu->kvm, 78))
1953                atomic_or(CPUSTAT_GED2, &vcpu->arch.sie_block->cpuflags);
1954        else if (test_kvm_facility(vcpu->kvm, 8))
1955                atomic_or(CPUSTAT_GED, &vcpu->arch.sie_block->cpuflags);
1956
1957        kvm_s390_vcpu_setup_model(vcpu);
1958
1959        /* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */
1960        if (MACHINE_HAS_ESOP)
1961                vcpu->arch.sie_block->ecb |= 0x02;
1962        if (test_kvm_facility(vcpu->kvm, 9))
1963                vcpu->arch.sie_block->ecb |= 0x04;
1964        if (test_kvm_facility(vcpu->kvm, 73))
1965                vcpu->arch.sie_block->ecb |= 0x10;
1966
1967        if (test_kvm_facility(vcpu->kvm, 8) && sclp.has_pfmfi)
1968                vcpu->arch.sie_block->ecb2 |= 0x08;
1969        vcpu->arch.sie_block->eca = 0x1002000U;
1970        if (sclp.has_cei)
1971                vcpu->arch.sie_block->eca |= 0x80000000U;
1972        if (sclp.has_ib)
1973                vcpu->arch.sie_block->eca |= 0x40000000U;
1974        if (sclp.has_siif)
1975                vcpu->arch.sie_block->eca |= 1;
1976        if (sclp.has_sigpif)
1977                vcpu->arch.sie_block->eca |= 0x10000000U;
1978        if (test_kvm_facility(vcpu->kvm, 129)) {
1979                vcpu->arch.sie_block->eca |= 0x00020000;
1980                vcpu->arch.sie_block->ecd |= 0x20000000;
1981        }
1982        vcpu->arch.sie_block->riccbd = (unsigned long) &vcpu->run->s.regs.riccb;
1983        vcpu->arch.sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE;
1984
1985        if (vcpu->kvm->arch.use_cmma) {
1986                rc = kvm_s390_vcpu_setup_cmma(vcpu);
1987                if (rc)
1988                        return rc;
1989        }
1990        hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1991        vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
1992
1993        kvm_s390_vcpu_crypto_setup(vcpu);
1994
1995        return rc;
1996}
1997
1998struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
1999                                      unsigned int id)
2000{
2001        struct kvm_vcpu *vcpu;
2002        struct sie_page *sie_page;
2003        int rc = -EINVAL;
2004
2005        if (!kvm_is_ucontrol(kvm) && !sca_can_add_vcpu(kvm, id))
2006                goto out;
2007
2008        rc = -ENOMEM;
2009
2010        vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
2011        if (!vcpu)
2012                goto out;
2013
2014        sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
2015        if (!sie_page)
2016                goto out_free_cpu;
2017
2018        vcpu->arch.sie_block = &sie_page->sie_block;
2019        vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;
2020
2021        /* the real guest size will always be smaller than msl */
2022        vcpu->arch.sie_block->mso = 0;
2023        vcpu->arch.sie_block->msl = sclp.hamax;
2024
2025        vcpu->arch.sie_block->icpua = id;
2026        spin_lock_init(&vcpu->arch.local_int.lock);
2027        vcpu->arch.local_int.float_int = &kvm->arch.float_int;
2028        vcpu->arch.local_int.wq = &vcpu->wq;
2029        vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
2030        seqcount_init(&vcpu->arch.cputm_seqcount);
2031
2032        rc = kvm_vcpu_init(vcpu, kvm, id);
2033        if (rc)
2034                goto out_free_sie_block;
2035        VM_EVENT(kvm, 3, "create cpu %d at 0x%pK, sie block at 0x%pK", id, vcpu,
2036                 vcpu->arch.sie_block);
2037        trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
2038
2039        return vcpu;
2040out_free_sie_block:
2041        free_page((unsigned long)(vcpu->arch.sie_block));
2042out_free_cpu:
2043        kmem_cache_free(kvm_vcpu_cache, vcpu);
2044out:
2045        return ERR_PTR(rc);
2046}
2047
2048int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
2049{
2050        return kvm_s390_vcpu_has_irq(vcpu, 0);
2051}
2052
2053void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu)
2054{
2055        atomic_or(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
2056        exit_sie(vcpu);
2057}
2058
2059void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu)
2060{
2061        atomic_andnot(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
2062}
2063
2064static void kvm_s390_vcpu_request(struct kvm_vcpu *vcpu)
2065{
2066        atomic_or(PROG_REQUEST, &vcpu->arch.sie_block->prog20);
2067        exit_sie(vcpu);
2068}
2069
2070static void kvm_s390_vcpu_request_handled(struct kvm_vcpu *vcpu)
2071{
2072        atomic_andnot(PROG_REQUEST, &vcpu->arch.sie_block->prog20);
2073}
2074
2075/*
2076 * Kick a guest cpu out of SIE and wait until SIE is not running.
2077 * If the CPU is not running (e.g. waiting as idle) the function will
2078 * return immediately. */
2079void exit_sie(struct kvm_vcpu *vcpu)
2080{
2081        atomic_or(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
2082        while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
2083                cpu_relax();
2084}
2085
2086/* Kick a guest cpu out of SIE to process a request synchronously */
2087void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu)
2088{
2089        kvm_make_request(req, vcpu);
2090        kvm_s390_vcpu_request(vcpu);
2091}
2092
2093static void kvm_gmap_notifier(struct gmap *gmap, unsigned long start,
2094                              unsigned long end)
2095{
2096        struct kvm *kvm = gmap->private;
2097        struct kvm_vcpu *vcpu;
2098        unsigned long prefix;
2099        int i;
2100
2101        if (gmap_is_shadow(gmap))
2102                return;
2103        if (start >= 1UL << 31)
2104                /* We are only interested in prefix pages */
2105                return;
2106        kvm_for_each_vcpu(i, vcpu, kvm) {
2107                /* match against both prefix pages */
2108                prefix = kvm_s390_get_prefix(vcpu);
2109                if (prefix <= end && start <= prefix + 2*PAGE_SIZE - 1) {
2110                        VCPU_EVENT(vcpu, 2, "gmap notifier for %lx-%lx",
2111                                   start, end);
2112                        kvm_s390_sync_request(KVM_REQ_MMU_RELOAD, vcpu);
2113                }
2114        }
2115}
2116
2117int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
2118{
2119        /* kvm common code refers to this, but never calls it */
2120        BUG();
2121        return 0;
2122}
2123
2124static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
2125                                           struct kvm_one_reg *reg)
2126{
2127        int r = -EINVAL;
2128
2129        switch (reg->id) {
2130        case KVM_REG_S390_TODPR:
2131                r = put_user(vcpu->arch.sie_block->todpr,
2132                             (u32 __user *)reg->addr);
2133                break;
2134        case KVM_REG_S390_EPOCHDIFF:
2135                r = put_user(vcpu->arch.sie_block->epoch,
2136                             (u64 __user *)reg->addr);
2137                break;
2138        case KVM_REG_S390_CPU_TIMER:
2139                r = put_user(kvm_s390_get_cpu_timer(vcpu),
2140                             (u64 __user *)reg->addr);
2141                break;
2142        case KVM_REG_S390_CLOCK_COMP:
2143                r = put_user(vcpu->arch.sie_block->ckc,
2144                             (u64 __user *)reg->addr);
2145                break;
2146        case KVM_REG_S390_PFTOKEN:
2147                r = put_user(vcpu->arch.pfault_token,
2148                             (u64 __user *)reg->addr);
2149                break;
2150        case KVM_REG_S390_PFCOMPARE:
2151                r = put_user(vcpu->arch.pfault_compare,
2152                             (u64 __user *)reg->addr);
2153                break;
2154        case KVM_REG_S390_PFSELECT:
2155                r = put_user(vcpu->arch.pfault_select,
2156                             (u64 __user *)reg->addr);
2157                break;
2158        case KVM_REG_S390_PP:
2159                r = put_user(vcpu->arch.sie_block->pp,
2160                             (u64 __user *)reg->addr);
2161                break;
2162        case KVM_REG_S390_GBEA:
2163                r = put_user(vcpu->arch.sie_block->gbea,
2164                             (u64 __user *)reg->addr);
2165                break;
2166        default:
2167                break;
2168        }
2169
2170        return r;
2171}
2172
2173static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
2174                                           struct kvm_one_reg *reg)
2175{
2176        int r = -EINVAL;
2177        __u64 val;
2178
2179        switch (reg->id) {
2180        case KVM_REG_S390_TODPR:
2181                r = get_user(vcpu->arch.sie_block->todpr,
2182                             (u32 __user *)reg->addr);
2183                break;
2184        case KVM_REG_S390_EPOCHDIFF:
2185                r = get_user(vcpu->arch.sie_block->epoch,
2186                             (u64 __user *)reg->addr);
2187                break;
2188        case KVM_REG_S390_CPU_TIMER:
2189                r = get_user(val, (u64 __user *)reg->addr);
2190                if (!r)
2191                        kvm_s390_set_cpu_timer(vcpu, val);
2192                break;
2193        case KVM_REG_S390_CLOCK_COMP:
2194                r = get_user(vcpu->arch.sie_block->ckc,
2195                             (u64 __user *)reg->addr);
2196                break;
2197        case KVM_REG_S390_PFTOKEN:
2198                r = get_user(vcpu->arch.pfault_token,
2199                             (u64 __user *)reg->addr);
2200                if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
2201                        kvm_clear_async_pf_completion_queue(vcpu);
2202                break;
2203        case KVM_REG_S390_PFCOMPARE:
2204                r = get_user(vcpu->arch.pfault_compare,
2205                             (u64 __user *)reg->addr);
2206                break;
2207        case KVM_REG_S390_PFSELECT:
2208                r = get_user(vcpu->arch.pfault_select,
2209                             (u64 __user *)reg->addr);
2210                break;
2211        case KVM_REG_S390_PP:
2212                r = get_user(vcpu->arch.sie_block->pp,
2213                             (u64 __user *)reg->addr);
2214                break;
2215        case KVM_REG_S390_GBEA:
2216                r = get_user(vcpu->arch.sie_block->gbea,
2217                             (u64 __user *)reg->addr);
2218                break;
2219        default:
2220                break;
2221        }
2222
2223        return r;
2224}
2225
2226static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
2227{
2228        kvm_s390_vcpu_initial_reset(vcpu);
2229        return 0;
2230}
2231
2232int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
2233{
2234        memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
2235        return 0;
2236}
2237
2238int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
2239{
2240        memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
2241        return 0;
2242}
2243
2244int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
2245                                  struct kvm_sregs *sregs)
2246{
2247        memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
2248        memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
2249        restore_access_regs(vcpu->run->s.regs.acrs);
2250        return 0;
2251}
2252
2253int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
2254                                  struct kvm_sregs *sregs)
2255{
2256        memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
2257        memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
2258        return 0;
2259}
2260
2261int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
2262{
2263        /* make sure the new values will be lazily loaded */
2264        save_fpu_regs();
2265        if (test_fp_ctl(fpu->fpc))
2266                return -EINVAL;
2267        current->thread.fpu.fpc = fpu->fpc;
2268        if (MACHINE_HAS_VX)
2269                convert_fp_to_vx((__vector128 *) vcpu->run->s.regs.vrs,
2270                                 (freg_t *) fpu->fprs);
2271        else
2272                memcpy(vcpu->run->s.regs.fprs, &fpu->fprs, sizeof(fpu->fprs));
2273        return 0;
2274}
2275
2276int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
2277{
2278        /* make sure we have the latest values */
2279        save_fpu_regs();
2280        if (MACHINE_HAS_VX)
2281                convert_vx_to_fp((freg_t *) fpu->fprs,
2282                                 (__vector128 *) vcpu->run->s.regs.vrs);
2283        else
2284                memcpy(fpu->fprs, vcpu->run->s.regs.fprs, sizeof(fpu->fprs));
2285        fpu->fpc = current->thread.fpu.fpc;
2286        return 0;
2287}
2288
2289static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
2290{
2291        int rc = 0;
2292
2293        if (!is_vcpu_stopped(vcpu))
2294                rc = -EBUSY;
2295        else {
2296                vcpu->run->psw_mask = psw.mask;
2297                vcpu->run->psw_addr = psw.addr;
2298        }
2299        return rc;
2300}
2301
2302int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
2303                                  struct kvm_translation *tr)
2304{
2305        return -EINVAL; /* not implemented yet */
2306}
2307
2308#define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \
2309                              KVM_GUESTDBG_USE_HW_BP | \
2310                              KVM_GUESTDBG_ENABLE)
2311
2312int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
2313                                        struct kvm_guest_debug *dbg)
2314{
2315        int rc = 0;
2316
2317        vcpu->guest_debug = 0;
2318        kvm_s390_clear_bp_data(vcpu);
2319
2320        if (dbg->control & ~VALID_GUESTDBG_FLAGS)
2321                return -EINVAL;
2322        if (!sclp.has_gpere)
2323                return -EINVAL;
2324
2325        if (dbg->control & KVM_GUESTDBG_ENABLE) {
2326                vcpu->guest_debug = dbg->control;
2327                /* enforce guest PER */
2328                atomic_or(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
2329
2330                if (dbg->control & KVM_GUESTDBG_USE_HW_BP)
2331                        rc = kvm_s390_import_bp_data(vcpu, dbg);
2332        } else {
2333                atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
2334                vcpu->arch.guestdbg.last_bp = 0;
2335        }
2336
2337        if (rc) {
2338                vcpu->guest_debug = 0;
2339                kvm_s390_clear_bp_data(vcpu);
2340                atomic_andnot(CPUSTAT_P, &vcpu->arch.sie_block->cpuflags);
2341        }
2342
2343        return rc;
2344}
2345
2346int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
2347                                    struct kvm_mp_state *mp_state)
2348{
2349        /* CHECK_STOP and LOAD are not supported yet */
2350        return is_vcpu_stopped(vcpu) ? KVM_MP_STATE_STOPPED :
2351                                       KVM_MP_STATE_OPERATING;
2352}
2353
2354int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
2355                                    struct kvm_mp_state *mp_state)
2356{
2357        int rc = 0;
2358
2359        /* user space knows about this interface - let it control the state */
2360        vcpu->kvm->arch.user_cpu_state_ctrl = 1;
2361
2362        switch (mp_state->mp_state) {
2363        case KVM_MP_STATE_STOPPED:
2364                kvm_s390_vcpu_stop(vcpu);
2365                break;
2366        case KVM_MP_STATE_OPERATING:
2367                kvm_s390_vcpu_start(vcpu);
2368                break;
2369        case KVM_MP_STATE_LOAD:
2370        case KVM_MP_STATE_CHECK_STOP:
2371                /* fall through - CHECK_STOP and LOAD are not supported yet */
2372        default:
2373                rc = -ENXIO;
2374        }
2375
2376        return rc;
2377}
2378
2379static bool ibs_enabled(struct kvm_vcpu *vcpu)
2380{
2381        return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_IBS;
2382}
2383
2384static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
2385{
2386retry:
2387        kvm_s390_vcpu_request_handled(vcpu);
2388        if (!vcpu->requests)
2389                return 0;
2390        /*
2391         * We use MMU_RELOAD just to re-arm the ipte notifier for the
2392         * guest prefix page. gmap_mprotect_notify will wait on the ptl lock.
2393         * This ensures that the ipte instruction for this request has
2394         * already finished. We might race against a second unmapper that
2395         * wants to set the blocking bit. Lets just retry the request loop.
2396         */
2397        if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
2398                int rc;
2399                rc = gmap_mprotect_notify(vcpu->arch.gmap,
2400                                          kvm_s390_get_prefix(vcpu),
2401                                          PAGE_SIZE * 2, PROT_WRITE);
2402                if (rc) {
2403                        kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
2404                        return rc;
2405                }
2406                goto retry;
2407        }
2408
2409        if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) {
2410                vcpu->arch.sie_block->ihcpu = 0xffff;
2411                goto retry;
2412        }
2413
2414        if (kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu)) {
2415                if (!ibs_enabled(vcpu)) {
2416                        trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 1);
2417                        atomic_or(CPUSTAT_IBS,
2418                                        &vcpu->arch.sie_block->cpuflags);
2419                }
2420                goto retry;
2421        }
2422
2423        if (kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu)) {
2424                if (ibs_enabled(vcpu)) {
2425                        trace_kvm_s390_enable_disable_ibs(vcpu->vcpu_id, 0);
2426                        atomic_andnot(CPUSTAT_IBS,
2427                                          &vcpu->arch.sie_block->cpuflags);
2428                }
2429                goto retry;
2430        }
2431
2432        if (kvm_check_request(KVM_REQ_ICPT_OPEREXC, vcpu)) {
2433                vcpu->arch.sie_block->ictl |= ICTL_OPEREXC;
2434                goto retry;
2435        }
2436
2437        /* nothing to do, just clear the request */
2438        clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
2439
2440        return 0;
2441}
2442
2443void kvm_s390_set_tod_clock(struct kvm *kvm, u64 tod)
2444{
2445        struct kvm_vcpu *vcpu;
2446        int i;
2447
2448        mutex_lock(&kvm->lock);
2449        preempt_disable();
2450        kvm->arch.epoch = tod - get_tod_clock();
2451        kvm_s390_vcpu_block_all(kvm);
2452        kvm_for_each_vcpu(i, vcpu, kvm)
2453                vcpu->arch.sie_block->epoch = kvm->arch.epoch;
2454        kvm_s390_vcpu_unblock_all(kvm);
2455        preempt_enable();
2456        mutex_unlock(&kvm->lock);
2457}
2458
2459/**
2460 * kvm_arch_fault_in_page - fault-in guest page if necessary
2461 * @vcpu: The corresponding virtual cpu
2462 * @gpa: Guest physical address
2463 * @writable: Whether the page should be writable or not
2464 *
2465 * Make sure that a guest page has been faulted-in on the host.
2466 *
2467 * Return: Zero on success, negative error code otherwise.
2468 */
2469long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable)
2470{
2471        return gmap_fault(vcpu->arch.gmap, gpa,
2472                          writable ? FAULT_FLAG_WRITE : 0);
2473}
2474
2475static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
2476                                      unsigned long token)
2477{
2478        struct kvm_s390_interrupt inti;
2479        struct kvm_s390_irq irq;
2480
2481        if (start_token) {
2482                irq.u.ext.ext_params2 = token;
2483                irq.type = KVM_S390_INT_PFAULT_INIT;
2484                WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &irq));
2485        } else {
2486                inti.type = KVM_S390_INT_PFAULT_DONE;
2487                inti.parm64 = token;
2488                WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
2489        }
2490}
2491
2492void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
2493                                     struct kvm_async_pf *work)
2494{
2495        trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
2496        __kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
2497}
2498
2499void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
2500                                 struct kvm_async_pf *work)
2501{
2502        trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
2503        __kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
2504}
2505
2506void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
2507                               struct kvm_async_pf *work)
2508{
2509        /* s390 will always inject the page directly */
2510}
2511
2512bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
2513{
2514        /*
2515         * s390 will always inject the page directly,
2516         * but we still want check_async_completion to cleanup
2517         */
2518        return true;
2519}
2520
2521static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
2522{
2523        hva_t hva;
2524        struct kvm_arch_async_pf arch;
2525        int rc;
2526
2527        if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
2528                return 0;
2529        if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
2530            vcpu->arch.pfault_compare)
2531                return 0;
2532        if (psw_extint_disabled(vcpu))
2533                return 0;
2534        if (kvm_s390_vcpu_has_irq(vcpu, 0))
2535                return 0;
2536        if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul))
2537                return 0;
2538        if (!vcpu->arch.gmap->pfault_enabled)
2539                return 0;
2540
2541        hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(current->thread.gmap_addr));
2542        hva += current->thread.gmap_addr & ~PAGE_MASK;
2543        if (read_guest_real(vcpu, vcpu->arch.pfault_token, &arch.pfault_token, 8))
2544                return 0;
2545
2546        rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
2547        return rc;
2548}
2549
2550static int vcpu_pre_run(struct kvm_vcpu *vcpu)
2551{
2552        int rc, cpuflags;
2553
2554        /*
2555         * On s390 notifications for arriving pages will be delivered directly
2556         * to the guest but the house keeping for completed pfaults is
2557         * handled outside the worker.
2558         */
2559        kvm_check_async_pf_completion(vcpu);
2560
2561        vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14];
2562        vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15];
2563
2564        if (need_resched())
2565                schedule();
2566
2567        if (test_cpu_flag(CIF_MCCK_PENDING))
2568                s390_handle_mcck();
2569
2570        if (!kvm_is_ucontrol(vcpu->kvm)) {
2571                rc = kvm_s390_deliver_pending_interrupts(vcpu);
2572                if (rc)
2573                        return rc;
2574        }
2575
2576        rc = kvm_s390_handle_requests(vcpu);
2577        if (rc)
2578                return rc;
2579
2580        if (guestdbg_enabled(vcpu)) {
2581                kvm_s390_backup_guest_per_regs(vcpu);
2582                kvm_s390_patch_guest_per_regs(vcpu);
2583        }
2584
2585        vcpu->arch.sie_block->icptcode = 0;
2586        cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
2587        VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
2588        trace_kvm_s390_sie_enter(vcpu, cpuflags);
2589
2590        return 0;
2591}
2592
2593static int vcpu_post_run_fault_in_sie(struct kvm_vcpu *vcpu)
2594{
2595        struct kvm_s390_pgm_info pgm_info = {
2596                .code = PGM_ADDRESSING,
2597        };
2598        u8 opcode, ilen;
2599        int rc;
2600
2601        VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
2602        trace_kvm_s390_sie_fault(vcpu);
2603
2604        /*
2605         * We want to inject an addressing exception, which is defined as a
2606         * suppressing or terminating exception. However, since we came here
2607         * by a DAT access exception, the PSW still points to the faulting
2608         * instruction since DAT exceptions are nullifying. So we've got
2609         * to look up the current opcode to get the length of the instruction
2610         * to be able to forward the PSW.
2611         */
2612        rc = read_guest_instr(vcpu, &opcode, 1);
2613        ilen = insn_length(opcode);
2614        if (rc < 0) {
2615                return rc;
2616        } else if (rc) {
2617                /* Instruction-Fetching Exceptions - we can't detect the ilen.
2618                 * Forward by arbitrary ilc, injection will take care of
2619                 * nullification if necessary.
2620                 */
2621                pgm_info = vcpu->arch.pgm;
2622                ilen = 4;
2623        }
2624        pgm_info.flags = ilen | KVM_S390_PGM_FLAGS_ILC_VALID;
2625        kvm_s390_forward_psw(vcpu, ilen);
2626        return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
2627}
2628
2629static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
2630{
2631        VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
2632                   vcpu->arch.sie_block->icptcode);
2633        trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
2634
2635        if (guestdbg_enabled(vcpu))
2636                kvm_s390_restore_guest_per_regs(vcpu);
2637
2638        vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14;
2639        vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15;
2640
2641        if (vcpu->arch.sie_block->icptcode > 0) {
2642                int rc = kvm_handle_sie_intercept(vcpu);
2643
2644                if (rc != -EOPNOTSUPP)
2645                        return rc;
2646                vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC;
2647                vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
2648                vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
2649                vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
2650                return -EREMOTE;
2651        } else if (exit_reason != -EFAULT) {
2652                vcpu->stat.exit_null++;
2653                return 0;
2654        } else if (kvm_is_ucontrol(vcpu->kvm)) {
2655                vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
2656                vcpu->run->s390_ucontrol.trans_exc_code =
2657                                                current->thread.gmap_addr;
2658                vcpu->run->s390_ucontrol.pgm_code = 0x10;
2659                return -EREMOTE;
2660        } else if (current->thread.gmap_pfault) {
2661                trace_kvm_s390_major_guest_pfault(vcpu);
2662                current->thread.gmap_pfault = 0;
2663                if (kvm_arch_setup_async_pf(vcpu))
2664                        return 0;
2665                return kvm_arch_fault_in_page(vcpu, current->thread.gmap_addr, 1);
2666        }
2667        return vcpu_post_run_fault_in_sie(vcpu);
2668}
2669
2670static int __vcpu_run(struct kvm_vcpu *vcpu)
2671{
2672        int rc, exit_reason;
2673
2674        /*
2675         * We try to hold kvm->srcu during most of vcpu_run (except when run-
2676         * ning the guest), so that memslots (and other stuff) are protected
2677         */
2678        vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
2679
2680        do {
2681                rc = vcpu_pre_run(vcpu);
2682                if (rc)
2683                        break;
2684
2685                srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
2686                /*
2687                 * As PF_VCPU will be used in fault handler, between
2688                 * guest_enter and guest_exit should be no uaccess.
2689                 */
2690                local_irq_disable();
2691                guest_enter_irqoff();
2692                __disable_cpu_timer_accounting(vcpu);
2693                local_irq_enable();
2694                exit_reason = sie64a(vcpu->arch.sie_block,
2695                                     vcpu->run->s.regs.gprs);
2696                local_irq_disable();
2697                __enable_cpu_timer_accounting(vcpu);
2698                guest_exit_irqoff();
2699                local_irq_enable();
2700                vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
2701
2702                rc = vcpu_post_run(vcpu, exit_reason);
2703        } while (!signal_pending(current) && !guestdbg_exit_pending(vcpu) && !rc);
2704
2705        srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
2706        return rc;
2707}
2708
2709static void sync_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
2710{
2711        vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
2712        vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
2713        if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX)
2714                kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
2715        if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
2716                memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
2717                /* some control register changes require a tlb flush */
2718                kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
2719        }
2720        if (kvm_run->kvm_dirty_regs & KVM_SYNC_ARCH0) {
2721                kvm_s390_set_cpu_timer(vcpu, kvm_run->s.regs.cputm);
2722                vcpu->arch.sie_block->ckc = kvm_run->s.regs.ckc;
2723                vcpu->arch.sie_block->todpr = kvm_run->s.regs.todpr;
2724                vcpu->arch.sie_block->pp = kvm_run->s.regs.pp;
2725                vcpu->arch.sie_block->gbea = kvm_run->s.regs.gbea;
2726        }
2727        if (kvm_run->kvm_dirty_regs & KVM_SYNC_PFAULT) {
2728                vcpu->arch.pfault_token = kvm_run->s.regs.pft;
2729                vcpu->arch.pfault_select = kvm_run->s.regs.pfs;
2730                vcpu->arch.pfault_compare = kvm_run->s.regs.pfc;
2731                if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
2732                        kvm_clear_async_pf_completion_queue(vcpu);
2733        }
2734        /*
2735         * If userspace sets the riccb (e.g. after migration) to a valid state,
2736         * we should enable RI here instead of doing the lazy enablement.
2737         */
2738        if ((kvm_run->kvm_dirty_regs & KVM_SYNC_RICCB) &&
2739            test_kvm_facility(vcpu->kvm, 64)) {
2740                struct runtime_instr_cb *riccb =
2741                        (struct runtime_instr_cb *) &kvm_run->s.regs.riccb;
2742
2743                if (riccb->valid)
2744                        vcpu->arch.sie_block->ecb3 |= 0x01;
2745        }
2746
2747        kvm_run->kvm_dirty_regs = 0;
2748}
2749
2750static void store_regs(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
2751{
2752        kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
2753        kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
2754        kvm_run->s.regs.prefix = kvm_s390_get_prefix(vcpu);
2755        memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
2756        kvm_run->s.regs.cputm = kvm_s390_get_cpu_timer(vcpu);
2757        kvm_run->s.regs.ckc = vcpu->arch.sie_block->ckc;
2758        kvm_run->s.regs.todpr = vcpu->arch.sie_block->todpr;
2759        kvm_run->s.regs.pp = vcpu->arch.sie_block->pp;
2760        kvm_run->s.regs.gbea = vcpu->arch.sie_block->gbea;
2761        kvm_run->s.regs.pft = vcpu->arch.pfault_token;
2762        kvm_run->s.regs.pfs = vcpu->arch.pfault_select;
2763        kvm_run->s.regs.pfc = vcpu->arch.pfault_compare;
2764}
2765
2766int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
2767{
2768        int rc;
2769        sigset_t sigsaved;
2770
2771        if (guestdbg_exit_pending(vcpu)) {
2772                kvm_s390_prepare_debug_exit(vcpu);
2773                return 0;
2774        }
2775
2776        if (vcpu->sigset_active)
2777                sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
2778
2779        if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm)) {
2780                kvm_s390_vcpu_start(vcpu);
2781        } else if (is_vcpu_stopped(vcpu)) {
2782                pr_err_ratelimited("can't run stopped vcpu %d\n",
2783                                   vcpu->vcpu_id);
2784                return -EINVAL;
2785        }
2786
2787        sync_regs(vcpu, kvm_run);
2788        enable_cpu_timer_accounting(vcpu);
2789
2790        might_fault();
2791        rc = __vcpu_run(vcpu);
2792
2793        if (signal_pending(current) && !rc) {
2794                kvm_run->exit_reason = KVM_EXIT_INTR;
2795                rc = -EINTR;
2796        }
2797
2798        if (guestdbg_exit_pending(vcpu) && !rc)  {
2799                kvm_s390_prepare_debug_exit(vcpu);
2800                rc = 0;
2801        }
2802
2803        if (rc == -EREMOTE) {
2804                /* userspace support is needed, kvm_run has been prepared */
2805                rc = 0;
2806        }
2807
2808        disable_cpu_timer_accounting(vcpu);
2809        store_regs(vcpu, kvm_run);
2810
2811        if (vcpu->sigset_active)
2812                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
2813
2814        vcpu->stat.exit_userspace++;
2815        return rc;
2816}
2817
2818/*
2819 * store status at address
2820 * we use have two special cases:
2821 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
2822 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
2823 */
2824int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long gpa)
2825{
2826        unsigned char archmode = 1;
2827        freg_t fprs[NUM_FPRS];
2828        unsigned int px;
2829        u64 clkcomp, cputm;
2830        int rc;
2831
2832        px = kvm_s390_get_prefix(vcpu);
2833        if (gpa == KVM_S390_STORE_STATUS_NOADDR) {
2834                if (write_guest_abs(vcpu, 163, &archmode, 1))
2835                        return -EFAULT;
2836                gpa = 0;
2837        } else if (gpa == KVM_S390_STORE_STATUS_PREFIXED) {
2838                if (write_guest_real(vcpu, 163, &archmode, 1))
2839                        return -EFAULT;
2840                gpa = px;
2841        } else
2842                gpa -= __LC_FPREGS_SAVE_AREA;
2843
2844        /* manually convert vector registers if necessary */
2845        if (MACHINE_HAS_VX) {
2846                convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs);
2847                rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA,
2848                                     fprs, 128);
2849        } else {
2850                rc = write_guest_abs(vcpu, gpa + __LC_FPREGS_SAVE_AREA,
2851                                     vcpu->run->s.regs.fprs, 128);
2852        }
2853        rc |= write_guest_abs(vcpu, gpa + __LC_GPREGS_SAVE_AREA,
2854                              vcpu->run->s.regs.gprs, 128);
2855        rc |= write_guest_abs(vcpu, gpa + __LC_PSW_SAVE_AREA,
2856                              &vcpu->arch.sie_block->gpsw, 16);
2857        rc |= write_guest_abs(vcpu, gpa + __LC_PREFIX_SAVE_AREA,
2858                              &px, 4);
2859        rc |= write_guest_abs(vcpu, gpa + __LC_FP_CREG_SAVE_AREA,
2860                              &vcpu->run->s.regs.fpc, 4);
2861        rc |= write_guest_abs(vcpu, gpa + __LC_TOD_PROGREG_SAVE_AREA,
2862                              &vcpu->arch.sie_block->todpr, 4);
2863        cputm = kvm_s390_get_cpu_timer(vcpu);
2864        rc |= write_guest_abs(vcpu, gpa + __LC_CPU_TIMER_SAVE_AREA,
2865                              &cputm, 8);
2866        clkcomp = vcpu->arch.sie_block->ckc >> 8;
2867        rc |= write_guest_abs(vcpu, gpa + __LC_CLOCK_COMP_SAVE_AREA,
2868                              &clkcomp, 8);
2869        rc |= write_guest_abs(vcpu, gpa + __LC_AREGS_SAVE_AREA,
2870                              &vcpu->run->s.regs.acrs, 64);
2871        rc |= write_guest_abs(vcpu, gpa + __LC_CREGS_SAVE_AREA,
2872                              &vcpu->arch.sie_block->gcr, 128);
2873        return rc ? -EFAULT : 0;
2874}
2875
2876int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
2877{
2878        /*
2879         * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
2880         * copying in vcpu load/put. Lets update our copies before we save
2881         * it into the save area
2882         */
2883        save_fpu_regs();
2884        vcpu->run->s.regs.fpc = current->thread.fpu.fpc;
2885        save_access_regs(vcpu->run->s.regs.acrs);
2886
2887        return kvm_s390_store_status_unloaded(vcpu, addr);
2888}
2889
2890static void __disable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
2891{
2892        kvm_check_request(KVM_REQ_ENABLE_IBS, vcpu);
2893        kvm_s390_sync_request(KVM_REQ_DISABLE_IBS, vcpu);
2894}
2895
2896static void __disable_ibs_on_all_vcpus(struct kvm *kvm)
2897{
2898        unsigned int i;
2899        struct kvm_vcpu *vcpu;
2900
2901        kvm_for_each_vcpu(i, vcpu, kvm) {
2902                __disable_ibs_on_vcpu(vcpu);
2903        }
2904}
2905
2906static void __enable_ibs_on_vcpu(struct kvm_vcpu *vcpu)
2907{
2908        if (!sclp.has_ibs)
2909                return;
2910        kvm_check_request(KVM_REQ_DISABLE_IBS, vcpu);
2911        kvm_s390_sync_request(KVM_REQ_ENABLE_IBS, vcpu);
2912}
2913
2914void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu)
2915{
2916        int i, online_vcpus, started_vcpus = 0;
2917
2918        if (!is_vcpu_stopped(vcpu))
2919                return;
2920
2921        trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 1);
2922        /* Only one cpu at a time may enter/leave the STOPPED state. */
2923        spin_lock(&vcpu->kvm->arch.start_stop_lock);
2924        online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
2925
2926        for (i = 0; i < online_vcpus; i++) {
2927                if (!is_vcpu_stopped(vcpu->kvm->vcpus[i]))
2928                        started_vcpus++;
2929        }
2930
2931        if (started_vcpus == 0) {
2932                /* we're the only active VCPU -> speed it up */
2933                __enable_ibs_on_vcpu(vcpu);
2934        } else if (started_vcpus == 1) {
2935                /*
2936                 * As we are starting a second VCPU, we have to disable
2937                 * the IBS facility on all VCPUs to remove potentially
2938                 * oustanding ENABLE requests.
2939                 */
2940                __disable_ibs_on_all_vcpus(vcpu->kvm);
2941        }
2942
2943        atomic_andnot(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
2944        /*
2945         * Another VCPU might have used IBS while we were offline.
2946         * Let's play safe and flush the VCPU at startup.
2947         */
2948        kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
2949        spin_unlock(&vcpu->kvm->arch.start_stop_lock);
2950        return;
2951}
2952
2953void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu)
2954{
2955        int i, online_vcpus, started_vcpus = 0;
2956        struct kvm_vcpu *started_vcpu = NULL;
2957
2958        if (is_vcpu_stopped(vcpu))
2959                return;
2960
2961        trace_kvm_s390_vcpu_start_stop(vcpu->vcpu_id, 0);
2962        /* Only one cpu at a time may enter/leave the STOPPED state. */
2963        spin_lock(&vcpu->kvm->arch.start_stop_lock);
2964        online_vcpus = atomic_read(&vcpu->kvm->online_vcpus);
2965
2966        /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */
2967        kvm_s390_clear_stop_irq(vcpu);
2968
2969        atomic_or(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
2970        __disable_ibs_on_vcpu(vcpu);
2971
2972        for (i = 0; i < online_vcpus; i++) {
2973                if (!is_vcpu_stopped(vcpu->kvm->vcpus[i])) {
2974                        started_vcpus++;
2975                        started_vcpu = vcpu->kvm->vcpus[i];
2976                }
2977        }
2978
2979        if (started_vcpus == 1) {
2980                /*
2981                 * As we only have one VCPU left, we want to enable the
2982                 * IBS facility for that VCPU to speed it up.
2983                 */
2984                __enable_ibs_on_vcpu(started_vcpu);
2985        }
2986
2987        spin_unlock(&vcpu->kvm->arch.start_stop_lock);
2988        return;
2989}
2990
2991static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
2992                                     struct kvm_enable_cap *cap)
2993{
2994        int r;
2995
2996        if (cap->flags)
2997                return -EINVAL;
2998
2999        switch (cap->cap) {
3000        case KVM_CAP_S390_CSS_SUPPORT:
3001                if (!vcpu->kvm->arch.css_support) {
3002                        vcpu->kvm->arch.css_support = 1;
3003                        VM_EVENT(vcpu->kvm, 3, "%s", "ENABLE: CSS support");
3004                        trace_kvm_s390_enable_css(vcpu->kvm);
3005                }
3006                r = 0;
3007                break;
3008        default:
3009                r = -EINVAL;
3010                break;
3011        }
3012        return r;
3013}
3014
3015static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,
3016                                  struct kvm_s390_mem_op *mop)
3017{
3018        void __user *uaddr = (void __user *)mop->buf;
3019        void *tmpbuf = NULL;
3020        int r, srcu_idx;
3021        const u64 supported_flags = KVM_S390_MEMOP_F_INJECT_EXCEPTION
3022                                    | KVM_S390_MEMOP_F_CHECK_ONLY;
3023
3024        if (mop->flags & ~supported_flags)
3025                return -EINVAL;
3026
3027        if (mop->size > MEM_OP_MAX_SIZE)
3028                return -E2BIG;
3029
3030        if (!(mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY)) {
3031                tmpbuf = vmalloc(mop->size);
3032                if (!tmpbuf)
3033                        return -ENOMEM;
3034        }
3035
3036        srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
3037
3038        switch (mop->op) {
3039        case KVM_S390_MEMOP_LOGICAL_READ:
3040                if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) {
3041                        r = check_gva_range(vcpu, mop->gaddr, mop->ar,
3042                                            mop->size, GACC_FETCH);
3043                        break;
3044                }
3045                r = read_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size);
3046                if (r == 0) {
3047                        if (copy_to_user(uaddr, tmpbuf, mop->size))
3048                                r = -EFAULT;
3049                }
3050                break;
3051        case KVM_S390_MEMOP_LOGICAL_WRITE:
3052                if (mop->flags & KVM_S390_MEMOP_F_CHECK_ONLY) {
3053                        r = check_gva_range(vcpu, mop->gaddr, mop->ar,
3054                                            mop->size, GACC_STORE);
3055                        break;
3056                }
3057                if (copy_from_user(tmpbuf, uaddr, mop->size)) {
3058                        r = -EFAULT;
3059                        break;
3060                }
3061                r = write_guest(vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size);
3062                break;
3063        default:
3064                r = -EINVAL;
3065        }
3066
3067        srcu_read_unlock(&vcpu->kvm->srcu, srcu_idx);
3068
3069        if (r > 0 && (mop->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION) != 0)
3070                kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm);
3071
3072        vfree(tmpbuf);
3073        return r;
3074}
3075
3076long kvm_arch_vcpu_ioctl(struct file *filp,
3077                         unsigned int ioctl, unsigned long arg)
3078{
3079        struct kvm_vcpu *vcpu = filp->private_data;
3080        void __user *argp = (void __user *)arg;
3081        int idx;
3082        long r;
3083
3084        switch (ioctl) {
3085        case KVM_S390_IRQ: {
3086                struct kvm_s390_irq s390irq;
3087
3088                r = -EFAULT;
3089                if (copy_from_user(&s390irq, argp, sizeof(s390irq)))
3090                        break;
3091                r = kvm_s390_inject_vcpu(vcpu, &s390irq);
3092                break;
3093        }
3094        case KVM_S390_INTERRUPT: {
3095                struct kvm_s390_interrupt s390int;
3096                struct kvm_s390_irq s390irq;
3097
3098                r = -EFAULT;
3099                if (copy_from_user(&s390int, argp, sizeof(s390int)))
3100                        break;
3101                if (s390int_to_s390irq(&s390int, &s390irq))
3102                        return -EINVAL;
3103                r = kvm_s390_inject_vcpu(vcpu, &s390irq);
3104                break;
3105        }
3106        case KVM_S390_STORE_STATUS:
3107                idx = srcu_read_lock(&vcpu->kvm->srcu);
3108                r = kvm_s390_vcpu_store_status(vcpu, arg);
3109                srcu_read_unlock(&vcpu->kvm->srcu, idx);
3110                break;
3111        case KVM_S390_SET_INITIAL_PSW: {
3112                psw_t psw;
3113
3114                r = -EFAULT;
3115                if (copy_from_user(&psw, argp, sizeof(psw)))
3116                        break;
3117                r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
3118                break;
3119        }
3120        case KVM_S390_INITIAL_RESET:
3121                r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
3122                break;
3123        case KVM_SET_ONE_REG:
3124        case KVM_GET_ONE_REG: {
3125                struct kvm_one_reg reg;
3126                r = -EFAULT;
3127                if (copy_from_user(&reg, argp, sizeof(reg)))
3128                        break;
3129                if (ioctl == KVM_SET_ONE_REG)
3130                        r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
3131                else
3132                        r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
3133                break;
3134        }
3135#ifdef CONFIG_KVM_S390_UCONTROL
3136        case KVM_S390_UCAS_MAP: {
3137                struct kvm_s390_ucas_mapping ucasmap;
3138
3139                if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
3140                        r = -EFAULT;
3141                        break;
3142                }
3143
3144                if (!kvm_is_ucontrol(vcpu->kvm)) {
3145                        r = -EINVAL;
3146                        break;
3147                }
3148
3149                r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
3150                                     ucasmap.vcpu_addr, ucasmap.length);
3151                break;
3152        }
3153        case KVM_S390_UCAS_UNMAP: {
3154                struct kvm_s390_ucas_mapping ucasmap;
3155
3156                if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
3157                        r = -EFAULT;
3158                        break;
3159                }
3160
3161                if (!kvm_is_ucontrol(vcpu->kvm)) {
3162                        r = -EINVAL;
3163                        break;
3164                }
3165
3166                r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
3167                        ucasmap.length);
3168                break;
3169        }
3170#endif
3171        case KVM_S390_VCPU_FAULT: {
3172                r = gmap_fault(vcpu->arch.gmap, arg, 0);
3173                break;
3174        }
3175        case KVM_ENABLE_CAP:
3176        {
3177                struct kvm_enable_cap cap;
3178                r = -EFAULT;
3179                if (copy_from_user(&cap, argp, sizeof(cap)))
3180                        break;
3181                r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
3182                break;
3183        }
3184        case KVM_S390_MEM_OP: {
3185                struct kvm_s390_mem_op mem_op;
3186
3187                if (copy_from_user(&mem_op, argp, sizeof(mem_op)) == 0)
3188                        r = kvm_s390_guest_mem_op(vcpu, &mem_op);
3189                else
3190                        r = -EFAULT;
3191                break;
3192        }
3193        case KVM_S390_SET_IRQ_STATE: {
3194                struct kvm_s390_irq_state irq_state;
3195
3196                r = -EFAULT;
3197                if (copy_from_user(&irq_state, argp, sizeof(irq_state)))
3198                        break;
3199                if (irq_state.len > VCPU_IRQS_MAX_BUF ||
3200                    irq_state.len == 0 ||
3201                    irq_state.len % sizeof(struct kvm_s390_irq) > 0) {
3202                        r = -EINVAL;
3203                        break;
3204                }
3205                r = kvm_s390_set_irq_state(vcpu,
3206                                           (void __user *) irq_state.buf,
3207                                           irq_state.len);
3208                break;
3209        }
3210        case KVM_S390_GET_IRQ_STATE: {
3211                struct kvm_s390_irq_state irq_state;
3212
3213                r = -EFAULT;
3214                if (copy_from_user(&irq_state, argp, sizeof(irq_state)))
3215                        break;
3216                if (irq_state.len == 0) {
3217                        r = -EINVAL;
3218                        break;
3219                }
3220                r = kvm_s390_get_irq_state(vcpu,
3221                                           (__u8 __user *)  irq_state.buf,
3222                                           irq_state.len);
3223                break;
3224        }
3225        default:
3226                r = -ENOTTY;
3227        }
3228        return r;
3229}
3230
3231int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
3232{
3233#ifdef CONFIG_KVM_S390_UCONTROL
3234        if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
3235                 && (kvm_is_ucontrol(vcpu->kvm))) {
3236                vmf->page = virt_to_page(vcpu->arch.sie_block);
3237                get_page(vmf->page);
3238                return 0;
3239        }
3240#endif
3241        return VM_FAULT_SIGBUS;
3242}
3243
3244int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
3245                            unsigned long npages)
3246{
3247        return 0;
3248}
3249
3250/* Section: memory related */
3251int kvm_arch_prepare_memory_region(struct kvm *kvm,
3252                                   struct kvm_memory_slot *memslot,
3253                                   const struct kvm_userspace_memory_region *mem,
3254                                   enum kvm_mr_change change)
3255{
3256        /* A few sanity checks. We can have memory slots which have to be
3257           located/ended at a segment boundary (1MB). The memory in userland is
3258           ok to be fragmented into various different vmas. It is okay to mmap()
3259           and munmap() stuff in this slot after doing this call at any time */
3260
3261        if (mem->userspace_addr & 0xffffful)
3262                return -EINVAL;
3263
3264        if (mem->memory_size & 0xffffful)
3265                return -EINVAL;
3266
3267        if (mem->guest_phys_addr + mem->memory_size > kvm->arch.mem_limit)
3268                return -EINVAL;
3269
3270        return 0;
3271}
3272
3273void kvm_arch_commit_memory_region(struct kvm *kvm,
3274                                const struct kvm_userspace_memory_region *mem,
3275                                const struct kvm_memory_slot *old,
3276                                const struct kvm_memory_slot *new,
3277                                enum kvm_mr_change change)
3278{
3279        int rc;
3280
3281        /* If the basics of the memslot do not change, we do not want
3282         * to update the gmap. Every update causes several unnecessary
3283         * segment translation exceptions. This is usually handled just
3284         * fine by the normal fault handler + gmap, but it will also
3285         * cause faults on the prefix page of running guest CPUs.
3286         */
3287        if (old->userspace_addr == mem->userspace_addr &&
3288            old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
3289            old->npages * PAGE_SIZE == mem->memory_size)
3290                return;
3291
3292        rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
3293                mem->guest_phys_addr, mem->memory_size);
3294        if (rc)
3295                pr_warn("failed to commit memory region\n");
3296        return;
3297}
3298
3299static inline unsigned long nonhyp_mask(int i)
3300{
3301        unsigned int nonhyp_fai = (sclp.hmfai << i * 2) >> 30;
3302
3303        return 0x0000ffffffffffffUL >> (nonhyp_fai << 4);
3304}
3305
3306void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu)
3307{
3308        vcpu->valid_wakeup = false;
3309}
3310
3311static int __init kvm_s390_init(void)
3312{
3313        int i;
3314
3315        if (!sclp.has_sief2) {
3316                pr_info("SIE not available\n");
3317                return -ENODEV;
3318        }
3319
3320        for (i = 0; i < 16; i++)
3321                kvm_s390_fac_list_mask[i] |=
3322                        S390_lowcore.stfle_fac_list[i] & nonhyp_mask(i);
3323
3324        return kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
3325}
3326
3327static void __exit kvm_s390_exit(void)
3328{
3329        kvm_exit();
3330}
3331
3332module_init(kvm_s390_init);
3333module_exit(kvm_s390_exit);
3334
3335/*
3336 * Enable autoloading of the kvm module.
3337 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
3338 * since x86 takes a different approach.
3339 */
3340#include <linux/miscdevice.h>
3341MODULE_ALIAS_MISCDEV(KVM_MINOR);
3342MODULE_ALIAS("devname:kvm");
Note: See TracBrowser for help on using the repository browser.