1 // SPDX-License-Identifier: GPL-2.0
3 * hosting IBM Z kernel virtual machines (s390x)
5 * Copyright IBM Corp. 2008, 2020
7 * Author(s): Carsten Otte <cotte@de.ibm.com>
8 * Christian Borntraeger <borntraeger@de.ibm.com>
9 * Heiko Carstens <heiko.carstens@de.ibm.com>
10 * Christian Ehrhardt <ehrhardt@de.ibm.com>
11 * Jason J. Herne <jjherne@us.ibm.com>
14 #define KMSG_COMPONENT "kvm-s390"
15 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
17 #include <linux/compiler.h>
18 #include <linux/err.h>
20 #include <linux/hrtimer.h>
21 #include <linux/init.h>
22 #include <linux/kvm.h>
23 #include <linux/kvm_host.h>
24 #include <linux/mman.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/random.h>
28 #include <linux/slab.h>
29 #include <linux/timer.h>
30 #include <linux/vmalloc.h>
31 #include <linux/bitmap.h>
32 #include <linux/sched/signal.h>
33 #include <linux/string.h>
35 #include <asm/asm-offsets.h>
36 #include <asm/lowcore.h>
38 #include <asm/pgtable.h>
41 #include <asm/switch_to.h>
44 #include <asm/cpacf.h>
45 #include <asm/timex.h>
51 #define CREATE_TRACE_POINTS
53 #include "trace-s390.h"
55 #define MEM_OP_MAX_SIZE 65536 /* Maximum transfer size for KVM_S390_MEM_OP */
57 #define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \
58 (KVM_MAX_VCPUS + LOCAL_IRQS))
60 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
61 #define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM
63 struct kvm_stats_debugfs_item debugfs_entries
[] = {
64 { "userspace_handled", VCPU_STAT(exit_userspace
) },
65 { "exit_null", VCPU_STAT(exit_null
) },
66 { "exit_validity", VCPU_STAT(exit_validity
) },
67 { "exit_stop_request", VCPU_STAT(exit_stop_request
) },
68 { "exit_external_request", VCPU_STAT(exit_external_request
) },
69 { "exit_io_request", VCPU_STAT(exit_io_request
) },
70 { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt
) },
71 { "exit_instruction", VCPU_STAT(exit_instruction
) },
72 { "exit_pei", VCPU_STAT(exit_pei
) },
73 { "exit_program_interruption", VCPU_STAT(exit_program_interruption
) },
74 { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program
) },
75 { "exit_operation_exception", VCPU_STAT(exit_operation_exception
) },
76 { "halt_successful_poll", VCPU_STAT(halt_successful_poll
) },
77 { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll
) },
78 { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid
) },
79 { "halt_no_poll_steal", VCPU_STAT(halt_no_poll_steal
) },
80 { "halt_wakeup", VCPU_STAT(halt_wakeup
) },
81 { "instruction_lctlg", VCPU_STAT(instruction_lctlg
) },
82 { "instruction_lctl", VCPU_STAT(instruction_lctl
) },
83 { "instruction_stctl", VCPU_STAT(instruction_stctl
) },
84 { "instruction_stctg", VCPU_STAT(instruction_stctg
) },
85 { "deliver_ckc", VCPU_STAT(deliver_ckc
) },
86 { "deliver_cputm", VCPU_STAT(deliver_cputm
) },
87 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal
) },
88 { "deliver_external_call", VCPU_STAT(deliver_external_call
) },
89 { "deliver_service_signal", VCPU_STAT(deliver_service_signal
) },
90 { "deliver_virtio", VCPU_STAT(deliver_virtio
) },
91 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal
) },
92 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal
) },
93 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal
) },
94 { "deliver_program", VCPU_STAT(deliver_program
) },
95 { "deliver_io", VCPU_STAT(deliver_io
) },
96 { "deliver_machine_check", VCPU_STAT(deliver_machine_check
) },
97 { "exit_wait_state", VCPU_STAT(exit_wait_state
) },
98 { "inject_ckc", VCPU_STAT(inject_ckc
) },
99 { "inject_cputm", VCPU_STAT(inject_cputm
) },
100 { "inject_external_call", VCPU_STAT(inject_external_call
) },
101 { "inject_float_mchk", VM_STAT(inject_float_mchk
) },
102 { "inject_emergency_signal", VCPU_STAT(inject_emergency_signal
) },
103 { "inject_io", VM_STAT(inject_io
) },
104 { "inject_mchk", VCPU_STAT(inject_mchk
) },
105 { "inject_pfault_done", VM_STAT(inject_pfault_done
) },
106 { "inject_program", VCPU_STAT(inject_program
) },
107 { "inject_restart", VCPU_STAT(inject_restart
) },
108 { "inject_service_signal", VM_STAT(inject_service_signal
) },
109 { "inject_set_prefix", VCPU_STAT(inject_set_prefix
) },
110 { "inject_stop_signal", VCPU_STAT(inject_stop_signal
) },
111 { "inject_pfault_init", VCPU_STAT(inject_pfault_init
) },
112 { "inject_virtio", VM_STAT(inject_virtio
) },
113 { "instruction_epsw", VCPU_STAT(instruction_epsw
) },
114 { "instruction_gs", VCPU_STAT(instruction_gs
) },
115 { "instruction_io_other", VCPU_STAT(instruction_io_other
) },
116 { "instruction_lpsw", VCPU_STAT(instruction_lpsw
) },
117 { "instruction_lpswe", VCPU_STAT(instruction_lpswe
) },
118 { "instruction_pfmf", VCPU_STAT(instruction_pfmf
) },
119 { "instruction_ptff", VCPU_STAT(instruction_ptff
) },
120 { "instruction_stidp", VCPU_STAT(instruction_stidp
) },
121 { "instruction_sck", VCPU_STAT(instruction_sck
) },
122 { "instruction_sckpf", VCPU_STAT(instruction_sckpf
) },
123 { "instruction_spx", VCPU_STAT(instruction_spx
) },
124 { "instruction_stpx", VCPU_STAT(instruction_stpx
) },
125 { "instruction_stap", VCPU_STAT(instruction_stap
) },
126 { "instruction_iske", VCPU_STAT(instruction_iske
) },
127 { "instruction_ri", VCPU_STAT(instruction_ri
) },
128 { "instruction_rrbe", VCPU_STAT(instruction_rrbe
) },
129 { "instruction_sske", VCPU_STAT(instruction_sske
) },
130 { "instruction_ipte_interlock", VCPU_STAT(instruction_ipte_interlock
) },
131 { "instruction_essa", VCPU_STAT(instruction_essa
) },
132 { "instruction_stsi", VCPU_STAT(instruction_stsi
) },
133 { "instruction_stfl", VCPU_STAT(instruction_stfl
) },
134 { "instruction_tb", VCPU_STAT(instruction_tb
) },
135 { "instruction_tpi", VCPU_STAT(instruction_tpi
) },
136 { "instruction_tprot", VCPU_STAT(instruction_tprot
) },
137 { "instruction_tsch", VCPU_STAT(instruction_tsch
) },
138 { "instruction_sthyi", VCPU_STAT(instruction_sthyi
) },
139 { "instruction_sie", VCPU_STAT(instruction_sie
) },
140 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense
) },
141 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running
) },
142 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call
) },
143 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency
) },
144 { "instruction_sigp_cond_emergency", VCPU_STAT(instruction_sigp_cond_emergency
) },
145 { "instruction_sigp_start", VCPU_STAT(instruction_sigp_start
) },
146 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop
) },
147 { "instruction_sigp_stop_store_status", VCPU_STAT(instruction_sigp_stop_store_status
) },
148 { "instruction_sigp_store_status", VCPU_STAT(instruction_sigp_store_status
) },
149 { "instruction_sigp_store_adtl_status", VCPU_STAT(instruction_sigp_store_adtl_status
) },
150 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch
) },
151 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix
) },
152 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart
) },
153 { "instruction_sigp_cpu_reset", VCPU_STAT(instruction_sigp_cpu_reset
) },
154 { "instruction_sigp_init_cpu_reset", VCPU_STAT(instruction_sigp_init_cpu_reset
) },
155 { "instruction_sigp_unknown", VCPU_STAT(instruction_sigp_unknown
) },
156 { "instruction_diag_10", VCPU_STAT(diagnose_10
) },
157 { "instruction_diag_44", VCPU_STAT(diagnose_44
) },
158 { "instruction_diag_9c", VCPU_STAT(diagnose_9c
) },
159 { "diag_9c_ignored", VCPU_STAT(diagnose_9c_ignored
) },
160 { "instruction_diag_258", VCPU_STAT(diagnose_258
) },
161 { "instruction_diag_308", VCPU_STAT(diagnose_308
) },
162 { "instruction_diag_500", VCPU_STAT(diagnose_500
) },
163 { "instruction_diag_other", VCPU_STAT(diagnose_other
) },
167 struct kvm_s390_tod_clock_ext
{
173 /* allow nested virtualization in KVM (if enabled by user space) */
175 module_param(nested
, int, S_IRUGO
);
176 MODULE_PARM_DESC(nested
, "Nested virtualization support");
178 /* allow 1m huge page guest backing, if !nested */
180 module_param(hpage
, int, 0444);
181 MODULE_PARM_DESC(hpage
, "1m huge page backing support");
183 /* maximum percentage of steal time for polling. >100 is treated like 100 */
184 static u8 halt_poll_max_steal
= 10;
185 module_param(halt_poll_max_steal
, byte
, 0644);
186 MODULE_PARM_DESC(halt_poll_max_steal
, "Maximum percentage of steal time to allow polling");
188 /* if set to true, the GISA will be initialized and used if available */
189 static bool use_gisa
= true;
190 module_param(use_gisa
, bool, 0644);
191 MODULE_PARM_DESC(use_gisa
, "Use the GISA if the host supports it.");
194 * For now we handle at most 16 double words as this is what the s390 base
195 * kernel handles and stores in the prefix page. If we ever need to go beyond
196 * this, this requires changes to code, but the external uapi can stay.
198 #define SIZE_INTERNAL 16
201 * Base feature mask that defines default mask for facilities. Consists of the
202 * defines in FACILITIES_KVM and the non-hypervisor managed bits.
204 static unsigned long kvm_s390_fac_base
[SIZE_INTERNAL
] = { FACILITIES_KVM
};
206 * Extended feature mask. Consists of the defines in FACILITIES_KVM_CPUMODEL
207 * and defines the facilities that can be enabled via a cpu model.
209 static unsigned long kvm_s390_fac_ext
[SIZE_INTERNAL
] = { FACILITIES_KVM_CPUMODEL
};
211 static unsigned long kvm_s390_fac_size(void)
213 BUILD_BUG_ON(SIZE_INTERNAL
> S390_ARCH_FAC_MASK_SIZE_U64
);
214 BUILD_BUG_ON(SIZE_INTERNAL
> S390_ARCH_FAC_LIST_SIZE_U64
);
215 BUILD_BUG_ON(SIZE_INTERNAL
* sizeof(unsigned long) >
216 sizeof(S390_lowcore
.stfle_fac_list
));
218 return SIZE_INTERNAL
;
221 /* available cpu features supported by kvm */
222 static DECLARE_BITMAP(kvm_s390_available_cpu_feat
, KVM_S390_VM_CPU_FEAT_NR_BITS
);
223 /* available subfunctions indicated via query / "test bit" */
224 static struct kvm_s390_vm_cpu_subfunc kvm_s390_available_subfunc
;
226 static struct gmap_notifier gmap_notifier
;
227 static struct gmap_notifier vsie_gmap_notifier
;
228 debug_info_t
*kvm_s390_dbf
;
229 debug_info_t
*kvm_s390_dbf_uv
;
231 /* Section: not file related */
232 int kvm_arch_hardware_enable(void)
234 /* every s390 is virtualization enabled ;-) */
238 int kvm_arch_check_processor_compat(void *opaque
)
243 /* forward declarations */
244 static void kvm_gmap_notifier(struct gmap
*gmap
, unsigned long start
,
246 static int sca_switch_to_extended(struct kvm
*kvm
);
248 static void kvm_clock_sync_scb(struct kvm_s390_sie_block
*scb
, u64 delta
)
253 * The TOD jumps by delta, we have to compensate this by adding
254 * -delta to the epoch.
258 /* sign-extension - we're adding to signed values below */
263 if (scb
->ecd
& ECD_MEF
) {
264 scb
->epdx
+= delta_idx
;
265 if (scb
->epoch
< delta
)
271 * This callback is executed during stop_machine(). All CPUs are therefore
272 * temporarily stopped. In order not to change guest behavior, we have to
273 * disable preemption whenever we touch the epoch of kvm and the VCPUs,
274 * so a CPU won't be stopped while calculating with the epoch.
276 static int kvm_clock_sync(struct notifier_block
*notifier
, unsigned long val
,
280 struct kvm_vcpu
*vcpu
;
282 unsigned long long *delta
= v
;
284 list_for_each_entry(kvm
, &vm_list
, vm_list
) {
285 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
286 kvm_clock_sync_scb(vcpu
->arch
.sie_block
, *delta
);
288 kvm
->arch
.epoch
= vcpu
->arch
.sie_block
->epoch
;
289 kvm
->arch
.epdx
= vcpu
->arch
.sie_block
->epdx
;
291 if (vcpu
->arch
.cputm_enabled
)
292 vcpu
->arch
.cputm_start
+= *delta
;
293 if (vcpu
->arch
.vsie_block
)
294 kvm_clock_sync_scb(vcpu
->arch
.vsie_block
,
301 static struct notifier_block kvm_clock_notifier
= {
302 .notifier_call
= kvm_clock_sync
,
305 int kvm_arch_hardware_setup(void *opaque
)
307 gmap_notifier
.notifier_call
= kvm_gmap_notifier
;
308 gmap_register_pte_notifier(&gmap_notifier
);
309 vsie_gmap_notifier
.notifier_call
= kvm_s390_vsie_gmap_notifier
;
310 gmap_register_pte_notifier(&vsie_gmap_notifier
);
311 atomic_notifier_chain_register(&s390_epoch_delta_notifier
,
312 &kvm_clock_notifier
);
316 void kvm_arch_hardware_unsetup(void)
318 gmap_unregister_pte_notifier(&gmap_notifier
);
319 gmap_unregister_pte_notifier(&vsie_gmap_notifier
);
320 atomic_notifier_chain_unregister(&s390_epoch_delta_notifier
,
321 &kvm_clock_notifier
);
324 static void allow_cpu_feat(unsigned long nr
)
326 set_bit_inv(nr
, kvm_s390_available_cpu_feat
);
329 static inline int plo_test_bit(unsigned char nr
)
331 register unsigned long r0
asm("0") = (unsigned long) nr
| 0x100;
335 /* Parameter registers are ignored for "test bit" */
345 static __always_inline
void __insn32_query(unsigned int opcode
, u8
*query
)
347 register unsigned long r0
asm("0") = 0; /* query function */
348 register unsigned long r1
asm("1") = (unsigned long) query
;
351 /* Parameter regs are ignored */
352 " .insn rrf,%[opc] << 16,2,4,6,0\n"
354 : "d" (r0
), "a" (r1
), [opc
] "i" (opcode
)
358 #define INSN_SORTL 0xb938
359 #define INSN_DFLTCC 0xb939
361 static void kvm_s390_cpu_feat_init(void)
365 for (i
= 0; i
< 256; ++i
) {
367 kvm_s390_available_subfunc
.plo
[i
>> 3] |= 0x80 >> (i
& 7);
370 if (test_facility(28)) /* TOD-clock steering */
371 ptff(kvm_s390_available_subfunc
.ptff
,
372 sizeof(kvm_s390_available_subfunc
.ptff
),
375 if (test_facility(17)) { /* MSA */
376 __cpacf_query(CPACF_KMAC
, (cpacf_mask_t
*)
377 kvm_s390_available_subfunc
.kmac
);
378 __cpacf_query(CPACF_KMC
, (cpacf_mask_t
*)
379 kvm_s390_available_subfunc
.kmc
);
380 __cpacf_query(CPACF_KM
, (cpacf_mask_t
*)
381 kvm_s390_available_subfunc
.km
);
382 __cpacf_query(CPACF_KIMD
, (cpacf_mask_t
*)
383 kvm_s390_available_subfunc
.kimd
);
384 __cpacf_query(CPACF_KLMD
, (cpacf_mask_t
*)
385 kvm_s390_available_subfunc
.klmd
);
387 if (test_facility(76)) /* MSA3 */
388 __cpacf_query(CPACF_PCKMO
, (cpacf_mask_t
*)
389 kvm_s390_available_subfunc
.pckmo
);
390 if (test_facility(77)) { /* MSA4 */
391 __cpacf_query(CPACF_KMCTR
, (cpacf_mask_t
*)
392 kvm_s390_available_subfunc
.kmctr
);
393 __cpacf_query(CPACF_KMF
, (cpacf_mask_t
*)
394 kvm_s390_available_subfunc
.kmf
);
395 __cpacf_query(CPACF_KMO
, (cpacf_mask_t
*)
396 kvm_s390_available_subfunc
.kmo
);
397 __cpacf_query(CPACF_PCC
, (cpacf_mask_t
*)
398 kvm_s390_available_subfunc
.pcc
);
400 if (test_facility(57)) /* MSA5 */
401 __cpacf_query(CPACF_PRNO
, (cpacf_mask_t
*)
402 kvm_s390_available_subfunc
.ppno
);
404 if (test_facility(146)) /* MSA8 */
405 __cpacf_query(CPACF_KMA
, (cpacf_mask_t
*)
406 kvm_s390_available_subfunc
.kma
);
408 if (test_facility(155)) /* MSA9 */
409 __cpacf_query(CPACF_KDSA
, (cpacf_mask_t
*)
410 kvm_s390_available_subfunc
.kdsa
);
412 if (test_facility(150)) /* SORTL */
413 __insn32_query(INSN_SORTL
, kvm_s390_available_subfunc
.sortl
);
415 if (test_facility(151)) /* DFLTCC */
416 __insn32_query(INSN_DFLTCC
, kvm_s390_available_subfunc
.dfltcc
);
418 if (MACHINE_HAS_ESOP
)
419 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_ESOP
);
421 * We need SIE support, ESOP (PROT_READ protection for gmap_shadow),
422 * 64bit SCAO (SCA passthrough) and IDTE (for gmap_shadow unshadowing).
424 if (!sclp
.has_sief2
|| !MACHINE_HAS_ESOP
|| !sclp
.has_64bscao
||
425 !test_facility(3) || !nested
)
427 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIEF2
);
428 if (sclp
.has_64bscao
)
429 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_64BSCAO
);
431 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_SIIF
);
433 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GPERE
);
435 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_GSLS
);
437 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IB
);
439 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_CEI
);
441 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_IBS
);
443 allow_cpu_feat(KVM_S390_VM_CPU_FEAT_KSS
);
445 * KVM_S390_VM_CPU_FEAT_SKEY: Wrong shadow of PTE.I bits will make
446 * all skey handling functions read/set the skey from the PGSTE
447 * instead of the real storage key.
449 * KVM_S390_VM_CPU_FEAT_CMMA: Wrong shadow of PTE.I bits will make
450 * pages being detected as preserved although they are resident.
452 * KVM_S390_VM_CPU_FEAT_PFMFI: Wrong shadow of PTE.I bits will
453 * have the same effect as for KVM_S390_VM_CPU_FEAT_SKEY.
455 * For KVM_S390_VM_CPU_FEAT_SKEY, KVM_S390_VM_CPU_FEAT_CMMA and
456 * KVM_S390_VM_CPU_FEAT_PFMFI, all PTE.I and PGSTE bits have to be
457 * correctly shadowed. We can do that for the PGSTE but not for PTE.I.
459 * KVM_S390_VM_CPU_FEAT_SIGPIF: Wrong SCB addresses in the SCA. We
460 * cannot easily shadow the SCA because of the ipte lock.
464 int kvm_arch_init(void *opaque
)
468 kvm_s390_dbf
= debug_register("kvm-trace", 32, 1, 7 * sizeof(long));
472 kvm_s390_dbf_uv
= debug_register("kvm-uv", 32, 1, 7 * sizeof(long));
473 if (!kvm_s390_dbf_uv
)
476 if (debug_register_view(kvm_s390_dbf
, &debug_sprintf_view
) ||
477 debug_register_view(kvm_s390_dbf_uv
, &debug_sprintf_view
))
480 kvm_s390_cpu_feat_init();
482 /* Register floating interrupt controller interface. */
483 rc
= kvm_register_device_ops(&kvm_flic_ops
, KVM_DEV_TYPE_FLIC
);
485 pr_err("A FLIC registration call failed with rc=%d\n", rc
);
489 rc
= kvm_s390_gib_init(GAL_ISC
);
500 void kvm_arch_exit(void)
502 kvm_s390_gib_destroy();
503 debug_unregister(kvm_s390_dbf
);
504 debug_unregister(kvm_s390_dbf_uv
);
507 /* Section: device related */
508 long kvm_arch_dev_ioctl(struct file
*filp
,
509 unsigned int ioctl
, unsigned long arg
)
511 if (ioctl
== KVM_S390_ENABLE_SIE
)
512 return s390_enable_sie();
516 int kvm_vm_ioctl_check_extension(struct kvm
*kvm
, long ext
)
521 case KVM_CAP_S390_PSW
:
522 case KVM_CAP_S390_GMAP
:
523 case KVM_CAP_SYNC_MMU
:
524 #ifdef CONFIG_KVM_S390_UCONTROL
525 case KVM_CAP_S390_UCONTROL
:
527 case KVM_CAP_ASYNC_PF
:
528 case KVM_CAP_SYNC_REGS
:
529 case KVM_CAP_ONE_REG
:
530 case KVM_CAP_ENABLE_CAP
:
531 case KVM_CAP_S390_CSS_SUPPORT
:
532 case KVM_CAP_IOEVENTFD
:
533 case KVM_CAP_DEVICE_CTRL
:
534 case KVM_CAP_S390_IRQCHIP
:
535 case KVM_CAP_VM_ATTRIBUTES
:
536 case KVM_CAP_MP_STATE
:
537 case KVM_CAP_IMMEDIATE_EXIT
:
538 case KVM_CAP_S390_INJECT_IRQ
:
539 case KVM_CAP_S390_USER_SIGP
:
540 case KVM_CAP_S390_USER_STSI
:
541 case KVM_CAP_S390_SKEYS
:
542 case KVM_CAP_S390_IRQ_STATE
:
543 case KVM_CAP_S390_USER_INSTR0
:
544 case KVM_CAP_S390_CMMA_MIGRATION
:
545 case KVM_CAP_S390_AIS
:
546 case KVM_CAP_S390_AIS_MIGRATION
:
547 case KVM_CAP_S390_VCPU_RESETS
:
548 case KVM_CAP_SET_GUEST_DEBUG
:
551 case KVM_CAP_S390_HPAGE_1M
:
553 if (hpage
&& !kvm_is_ucontrol(kvm
))
556 case KVM_CAP_S390_MEM_OP
:
559 case KVM_CAP_NR_VCPUS
:
560 case KVM_CAP_MAX_VCPUS
:
561 case KVM_CAP_MAX_VCPU_ID
:
562 r
= KVM_S390_BSCA_CPU_SLOTS
;
563 if (!kvm_s390_use_sca_entries())
565 else if (sclp
.has_esca
&& sclp
.has_64bscao
)
566 r
= KVM_S390_ESCA_CPU_SLOTS
;
568 case KVM_CAP_S390_COW
:
569 r
= MACHINE_HAS_ESOP
;
571 case KVM_CAP_S390_VECTOR_REGISTERS
:
574 case KVM_CAP_S390_RI
:
575 r
= test_facility(64);
577 case KVM_CAP_S390_GS
:
578 r
= test_facility(133);
580 case KVM_CAP_S390_BPB
:
581 r
= test_facility(82);
583 case KVM_CAP_S390_PROTECTED
:
584 r
= is_prot_virt_host();
592 void kvm_arch_sync_dirty_log(struct kvm
*kvm
, struct kvm_memory_slot
*memslot
)
595 gfn_t cur_gfn
, last_gfn
;
596 unsigned long gaddr
, vmaddr
;
597 struct gmap
*gmap
= kvm
->arch
.gmap
;
598 DECLARE_BITMAP(bitmap
, _PAGE_ENTRIES
);
600 /* Loop over all guest segments */
601 cur_gfn
= memslot
->base_gfn
;
602 last_gfn
= memslot
->base_gfn
+ memslot
->npages
;
603 for (; cur_gfn
<= last_gfn
; cur_gfn
+= _PAGE_ENTRIES
) {
604 gaddr
= gfn_to_gpa(cur_gfn
);
605 vmaddr
= gfn_to_hva_memslot(memslot
, cur_gfn
);
606 if (kvm_is_error_hva(vmaddr
))
609 bitmap_zero(bitmap
, _PAGE_ENTRIES
);
610 gmap_sync_dirty_log_pmd(gmap
, bitmap
, gaddr
, vmaddr
);
611 for (i
= 0; i
< _PAGE_ENTRIES
; i
++) {
612 if (test_bit(i
, bitmap
))
613 mark_page_dirty(kvm
, cur_gfn
+ i
);
616 if (fatal_signal_pending(current
))
622 /* Section: vm related */
623 static void sca_del_vcpu(struct kvm_vcpu
*vcpu
);
626 * Get (and clear) the dirty memory log for a memory slot.
628 int kvm_vm_ioctl_get_dirty_log(struct kvm
*kvm
,
629 struct kvm_dirty_log
*log
)
633 struct kvm_memory_slot
*memslot
;
636 if (kvm_is_ucontrol(kvm
))
639 mutex_lock(&kvm
->slots_lock
);
642 if (log
->slot
>= KVM_USER_MEM_SLOTS
)
645 r
= kvm_get_dirty_log(kvm
, log
, &is_dirty
, &memslot
);
649 /* Clear the dirty log */
651 n
= kvm_dirty_bitmap_bytes(memslot
);
652 memset(memslot
->dirty_bitmap
, 0, n
);
656 mutex_unlock(&kvm
->slots_lock
);
660 static void icpt_operexc_on_all_vcpus(struct kvm
*kvm
)
663 struct kvm_vcpu
*vcpu
;
665 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
666 kvm_s390_sync_request(KVM_REQ_ICPT_OPEREXC
, vcpu
);
670 int kvm_vm_ioctl_enable_cap(struct kvm
*kvm
, struct kvm_enable_cap
*cap
)
678 case KVM_CAP_S390_IRQCHIP
:
679 VM_EVENT(kvm
, 3, "%s", "ENABLE: CAP_S390_IRQCHIP");
680 kvm
->arch
.use_irqchip
= 1;
683 case KVM_CAP_S390_USER_SIGP
:
684 VM_EVENT(kvm
, 3, "%s", "ENABLE: CAP_S390_USER_SIGP");
685 kvm
->arch
.user_sigp
= 1;
688 case KVM_CAP_S390_VECTOR_REGISTERS
:
689 mutex_lock(&kvm
->lock
);
690 if (kvm
->created_vcpus
) {
692 } else if (MACHINE_HAS_VX
) {
693 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 129);
694 set_kvm_facility(kvm
->arch
.model
.fac_list
, 129);
695 if (test_facility(134)) {
696 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 134);
697 set_kvm_facility(kvm
->arch
.model
.fac_list
, 134);
699 if (test_facility(135)) {
700 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 135);
701 set_kvm_facility(kvm
->arch
.model
.fac_list
, 135);
703 if (test_facility(148)) {
704 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 148);
705 set_kvm_facility(kvm
->arch
.model
.fac_list
, 148);
707 if (test_facility(152)) {
708 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 152);
709 set_kvm_facility(kvm
->arch
.model
.fac_list
, 152);
714 mutex_unlock(&kvm
->lock
);
715 VM_EVENT(kvm
, 3, "ENABLE: CAP_S390_VECTOR_REGISTERS %s",
716 r
? "(not available)" : "(success)");
718 case KVM_CAP_S390_RI
:
720 mutex_lock(&kvm
->lock
);
721 if (kvm
->created_vcpus
) {
723 } else if (test_facility(64)) {
724 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 64);
725 set_kvm_facility(kvm
->arch
.model
.fac_list
, 64);
728 mutex_unlock(&kvm
->lock
);
729 VM_EVENT(kvm
, 3, "ENABLE: CAP_S390_RI %s",
730 r
? "(not available)" : "(success)");
732 case KVM_CAP_S390_AIS
:
733 mutex_lock(&kvm
->lock
);
734 if (kvm
->created_vcpus
) {
737 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 72);
738 set_kvm_facility(kvm
->arch
.model
.fac_list
, 72);
741 mutex_unlock(&kvm
->lock
);
742 VM_EVENT(kvm
, 3, "ENABLE: AIS %s",
743 r
? "(not available)" : "(success)");
745 case KVM_CAP_S390_GS
:
747 mutex_lock(&kvm
->lock
);
748 if (kvm
->created_vcpus
) {
750 } else if (test_facility(133)) {
751 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 133);
752 set_kvm_facility(kvm
->arch
.model
.fac_list
, 133);
755 mutex_unlock(&kvm
->lock
);
756 VM_EVENT(kvm
, 3, "ENABLE: CAP_S390_GS %s",
757 r
? "(not available)" : "(success)");
759 case KVM_CAP_S390_HPAGE_1M
:
760 mutex_lock(&kvm
->lock
);
761 if (kvm
->created_vcpus
)
763 else if (!hpage
|| kvm
->arch
.use_cmma
|| kvm_is_ucontrol(kvm
))
767 down_write(&kvm
->mm
->mmap_sem
);
768 kvm
->mm
->context
.allow_gmap_hpage_1m
= 1;
769 up_write(&kvm
->mm
->mmap_sem
);
771 * We might have to create fake 4k page
772 * tables. To avoid that the hardware works on
773 * stale PGSTEs, we emulate these instructions.
775 kvm
->arch
.use_skf
= 0;
776 kvm
->arch
.use_pfmfi
= 0;
778 mutex_unlock(&kvm
->lock
);
779 VM_EVENT(kvm
, 3, "ENABLE: CAP_S390_HPAGE %s",
780 r
? "(not available)" : "(success)");
782 case KVM_CAP_S390_USER_STSI
:
783 VM_EVENT(kvm
, 3, "%s", "ENABLE: CAP_S390_USER_STSI");
784 kvm
->arch
.user_stsi
= 1;
787 case KVM_CAP_S390_USER_INSTR0
:
788 VM_EVENT(kvm
, 3, "%s", "ENABLE: CAP_S390_USER_INSTR0");
789 kvm
->arch
.user_instr0
= 1;
790 icpt_operexc_on_all_vcpus(kvm
);
800 static int kvm_s390_get_mem_control(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
804 switch (attr
->attr
) {
805 case KVM_S390_VM_MEM_LIMIT_SIZE
:
807 VM_EVENT(kvm
, 3, "QUERY: max guest memory: %lu bytes",
808 kvm
->arch
.mem_limit
);
809 if (put_user(kvm
->arch
.mem_limit
, (u64 __user
*)attr
->addr
))
819 static int kvm_s390_set_mem_control(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
823 switch (attr
->attr
) {
824 case KVM_S390_VM_MEM_ENABLE_CMMA
:
829 VM_EVENT(kvm
, 3, "%s", "ENABLE: CMMA support");
830 mutex_lock(&kvm
->lock
);
831 if (kvm
->created_vcpus
)
833 else if (kvm
->mm
->context
.allow_gmap_hpage_1m
)
836 kvm
->arch
.use_cmma
= 1;
837 /* Not compatible with cmma. */
838 kvm
->arch
.use_pfmfi
= 0;
841 mutex_unlock(&kvm
->lock
);
843 case KVM_S390_VM_MEM_CLR_CMMA
:
848 if (!kvm
->arch
.use_cmma
)
851 VM_EVENT(kvm
, 3, "%s", "RESET: CMMA states");
852 mutex_lock(&kvm
->lock
);
853 idx
= srcu_read_lock(&kvm
->srcu
);
854 s390_reset_cmma(kvm
->arch
.gmap
->mm
);
855 srcu_read_unlock(&kvm
->srcu
, idx
);
856 mutex_unlock(&kvm
->lock
);
859 case KVM_S390_VM_MEM_LIMIT_SIZE
: {
860 unsigned long new_limit
;
862 if (kvm_is_ucontrol(kvm
))
865 if (get_user(new_limit
, (u64 __user
*)attr
->addr
))
868 if (kvm
->arch
.mem_limit
!= KVM_S390_NO_MEM_LIMIT
&&
869 new_limit
> kvm
->arch
.mem_limit
)
875 /* gmap_create takes last usable address */
876 if (new_limit
!= KVM_S390_NO_MEM_LIMIT
)
880 mutex_lock(&kvm
->lock
);
881 if (!kvm
->created_vcpus
) {
882 /* gmap_create will round the limit up */
883 struct gmap
*new = gmap_create(current
->mm
, new_limit
);
888 gmap_remove(kvm
->arch
.gmap
);
890 kvm
->arch
.gmap
= new;
894 mutex_unlock(&kvm
->lock
);
895 VM_EVENT(kvm
, 3, "SET: max guest address: %lu", new_limit
);
896 VM_EVENT(kvm
, 3, "New guest asce: 0x%pK",
897 (void *) kvm
->arch
.gmap
->asce
);
907 static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu
*vcpu
);
909 void kvm_s390_vcpu_crypto_reset_all(struct kvm
*kvm
)
911 struct kvm_vcpu
*vcpu
;
914 kvm_s390_vcpu_block_all(kvm
);
916 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
917 kvm_s390_vcpu_crypto_setup(vcpu
);
918 /* recreate the shadow crycb by leaving the VSIE handler */
919 kvm_s390_sync_request(KVM_REQ_VSIE_RESTART
, vcpu
);
922 kvm_s390_vcpu_unblock_all(kvm
);
925 static int kvm_s390_vm_set_crypto(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
927 mutex_lock(&kvm
->lock
);
928 switch (attr
->attr
) {
929 case KVM_S390_VM_CRYPTO_ENABLE_AES_KW
:
930 if (!test_kvm_facility(kvm
, 76)) {
931 mutex_unlock(&kvm
->lock
);
935 kvm
->arch
.crypto
.crycb
->aes_wrapping_key_mask
,
936 sizeof(kvm
->arch
.crypto
.crycb
->aes_wrapping_key_mask
));
937 kvm
->arch
.crypto
.aes_kw
= 1;
938 VM_EVENT(kvm
, 3, "%s", "ENABLE: AES keywrapping support");
940 case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW
:
941 if (!test_kvm_facility(kvm
, 76)) {
942 mutex_unlock(&kvm
->lock
);
946 kvm
->arch
.crypto
.crycb
->dea_wrapping_key_mask
,
947 sizeof(kvm
->arch
.crypto
.crycb
->dea_wrapping_key_mask
));
948 kvm
->arch
.crypto
.dea_kw
= 1;
949 VM_EVENT(kvm
, 3, "%s", "ENABLE: DEA keywrapping support");
951 case KVM_S390_VM_CRYPTO_DISABLE_AES_KW
:
952 if (!test_kvm_facility(kvm
, 76)) {
953 mutex_unlock(&kvm
->lock
);
956 kvm
->arch
.crypto
.aes_kw
= 0;
957 memset(kvm
->arch
.crypto
.crycb
->aes_wrapping_key_mask
, 0,
958 sizeof(kvm
->arch
.crypto
.crycb
->aes_wrapping_key_mask
));
959 VM_EVENT(kvm
, 3, "%s", "DISABLE: AES keywrapping support");
961 case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW
:
962 if (!test_kvm_facility(kvm
, 76)) {
963 mutex_unlock(&kvm
->lock
);
966 kvm
->arch
.crypto
.dea_kw
= 0;
967 memset(kvm
->arch
.crypto
.crycb
->dea_wrapping_key_mask
, 0,
968 sizeof(kvm
->arch
.crypto
.crycb
->dea_wrapping_key_mask
));
969 VM_EVENT(kvm
, 3, "%s", "DISABLE: DEA keywrapping support");
971 case KVM_S390_VM_CRYPTO_ENABLE_APIE
:
972 if (!ap_instructions_available()) {
973 mutex_unlock(&kvm
->lock
);
976 kvm
->arch
.crypto
.apie
= 1;
978 case KVM_S390_VM_CRYPTO_DISABLE_APIE
:
979 if (!ap_instructions_available()) {
980 mutex_unlock(&kvm
->lock
);
983 kvm
->arch
.crypto
.apie
= 0;
986 mutex_unlock(&kvm
->lock
);
990 kvm_s390_vcpu_crypto_reset_all(kvm
);
991 mutex_unlock(&kvm
->lock
);
995 static void kvm_s390_sync_request_broadcast(struct kvm
*kvm
, int req
)
998 struct kvm_vcpu
*vcpu
;
1000 kvm_for_each_vcpu(cx
, vcpu
, kvm
)
1001 kvm_s390_sync_request(req
, vcpu
);
1005 * Must be called with kvm->srcu held to avoid races on memslots, and with
1006 * kvm->slots_lock to avoid races with ourselves and kvm_s390_vm_stop_migration.
1008 static int kvm_s390_vm_start_migration(struct kvm
*kvm
)
1010 struct kvm_memory_slot
*ms
;
1011 struct kvm_memslots
*slots
;
1012 unsigned long ram_pages
= 0;
1015 /* migration mode already enabled */
1016 if (kvm
->arch
.migration_mode
)
1018 slots
= kvm_memslots(kvm
);
1019 if (!slots
|| !slots
->used_slots
)
1022 if (!kvm
->arch
.use_cmma
) {
1023 kvm
->arch
.migration_mode
= 1;
1026 /* mark all the pages in active slots as dirty */
1027 for (slotnr
= 0; slotnr
< slots
->used_slots
; slotnr
++) {
1028 ms
= slots
->memslots
+ slotnr
;
1029 if (!ms
->dirty_bitmap
)
1032 * The second half of the bitmap is only used on x86,
1033 * and would be wasted otherwise, so we put it to good
1034 * use here to keep track of the state of the storage
1037 memset(kvm_second_dirty_bitmap(ms
), 0xff, kvm_dirty_bitmap_bytes(ms
));
1038 ram_pages
+= ms
->npages
;
1040 atomic64_set(&kvm
->arch
.cmma_dirty_pages
, ram_pages
);
1041 kvm
->arch
.migration_mode
= 1;
1042 kvm_s390_sync_request_broadcast(kvm
, KVM_REQ_START_MIGRATION
);
1047 * Must be called with kvm->slots_lock to avoid races with ourselves and
1048 * kvm_s390_vm_start_migration.
1050 static int kvm_s390_vm_stop_migration(struct kvm
*kvm
)
1052 /* migration mode already disabled */
1053 if (!kvm
->arch
.migration_mode
)
1055 kvm
->arch
.migration_mode
= 0;
1056 if (kvm
->arch
.use_cmma
)
1057 kvm_s390_sync_request_broadcast(kvm
, KVM_REQ_STOP_MIGRATION
);
1061 static int kvm_s390_vm_set_migration(struct kvm
*kvm
,
1062 struct kvm_device_attr
*attr
)
1066 mutex_lock(&kvm
->slots_lock
);
1067 switch (attr
->attr
) {
1068 case KVM_S390_VM_MIGRATION_START
:
1069 res
= kvm_s390_vm_start_migration(kvm
);
1071 case KVM_S390_VM_MIGRATION_STOP
:
1072 res
= kvm_s390_vm_stop_migration(kvm
);
1077 mutex_unlock(&kvm
->slots_lock
);
1082 static int kvm_s390_vm_get_migration(struct kvm
*kvm
,
1083 struct kvm_device_attr
*attr
)
1085 u64 mig
= kvm
->arch
.migration_mode
;
1087 if (attr
->attr
!= KVM_S390_VM_MIGRATION_STATUS
)
1090 if (copy_to_user((void __user
*)attr
->addr
, &mig
, sizeof(mig
)))
1095 static int kvm_s390_set_tod_ext(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1097 struct kvm_s390_vm_tod_clock gtod
;
1099 if (copy_from_user(>od
, (void __user
*)attr
->addr
, sizeof(gtod
)))
1102 if (!test_kvm_facility(kvm
, 139) && gtod
.epoch_idx
)
1104 kvm_s390_set_tod_clock(kvm
, >od
);
1106 VM_EVENT(kvm
, 3, "SET: TOD extension: 0x%x, TOD base: 0x%llx",
1107 gtod
.epoch_idx
, gtod
.tod
);
1112 static int kvm_s390_set_tod_high(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1116 if (copy_from_user(>od_high
, (void __user
*)attr
->addr
,
1122 VM_EVENT(kvm
, 3, "SET: TOD extension: 0x%x", gtod_high
);
1127 static int kvm_s390_set_tod_low(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1129 struct kvm_s390_vm_tod_clock gtod
= { 0 };
1131 if (copy_from_user(>od
.tod
, (void __user
*)attr
->addr
,
1135 kvm_s390_set_tod_clock(kvm
, >od
);
1136 VM_EVENT(kvm
, 3, "SET: TOD base: 0x%llx", gtod
.tod
);
1140 static int kvm_s390_set_tod(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1147 switch (attr
->attr
) {
1148 case KVM_S390_VM_TOD_EXT
:
1149 ret
= kvm_s390_set_tod_ext(kvm
, attr
);
1151 case KVM_S390_VM_TOD_HIGH
:
1152 ret
= kvm_s390_set_tod_high(kvm
, attr
);
1154 case KVM_S390_VM_TOD_LOW
:
1155 ret
= kvm_s390_set_tod_low(kvm
, attr
);
1164 static void kvm_s390_get_tod_clock(struct kvm
*kvm
,
1165 struct kvm_s390_vm_tod_clock
*gtod
)
1167 struct kvm_s390_tod_clock_ext htod
;
1171 get_tod_clock_ext((char *)&htod
);
1173 gtod
->tod
= htod
.tod
+ kvm
->arch
.epoch
;
1174 gtod
->epoch_idx
= 0;
1175 if (test_kvm_facility(kvm
, 139)) {
1176 gtod
->epoch_idx
= htod
.epoch_idx
+ kvm
->arch
.epdx
;
1177 if (gtod
->tod
< htod
.tod
)
1178 gtod
->epoch_idx
+= 1;
1184 static int kvm_s390_get_tod_ext(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1186 struct kvm_s390_vm_tod_clock gtod
;
1188 memset(>od
, 0, sizeof(gtod
));
1189 kvm_s390_get_tod_clock(kvm
, >od
);
1190 if (copy_to_user((void __user
*)attr
->addr
, >od
, sizeof(gtod
)))
1193 VM_EVENT(kvm
, 3, "QUERY: TOD extension: 0x%x, TOD base: 0x%llx",
1194 gtod
.epoch_idx
, gtod
.tod
);
1198 static int kvm_s390_get_tod_high(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1202 if (copy_to_user((void __user
*)attr
->addr
, >od_high
,
1205 VM_EVENT(kvm
, 3, "QUERY: TOD extension: 0x%x", gtod_high
);
1210 static int kvm_s390_get_tod_low(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1214 gtod
= kvm_s390_get_tod_clock_fast(kvm
);
1215 if (copy_to_user((void __user
*)attr
->addr
, >od
, sizeof(gtod
)))
1217 VM_EVENT(kvm
, 3, "QUERY: TOD base: 0x%llx", gtod
);
1222 static int kvm_s390_get_tod(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1229 switch (attr
->attr
) {
1230 case KVM_S390_VM_TOD_EXT
:
1231 ret
= kvm_s390_get_tod_ext(kvm
, attr
);
1233 case KVM_S390_VM_TOD_HIGH
:
1234 ret
= kvm_s390_get_tod_high(kvm
, attr
);
1236 case KVM_S390_VM_TOD_LOW
:
1237 ret
= kvm_s390_get_tod_low(kvm
, attr
);
1246 static int kvm_s390_set_processor(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1248 struct kvm_s390_vm_cpu_processor
*proc
;
1249 u16 lowest_ibc
, unblocked_ibc
;
1252 mutex_lock(&kvm
->lock
);
1253 if (kvm
->created_vcpus
) {
1257 proc
= kzalloc(sizeof(*proc
), GFP_KERNEL
);
1262 if (!copy_from_user(proc
, (void __user
*)attr
->addr
,
1264 kvm
->arch
.model
.cpuid
= proc
->cpuid
;
1265 lowest_ibc
= sclp
.ibc
>> 16 & 0xfff;
1266 unblocked_ibc
= sclp
.ibc
& 0xfff;
1267 if (lowest_ibc
&& proc
->ibc
) {
1268 if (proc
->ibc
> unblocked_ibc
)
1269 kvm
->arch
.model
.ibc
= unblocked_ibc
;
1270 else if (proc
->ibc
< lowest_ibc
)
1271 kvm
->arch
.model
.ibc
= lowest_ibc
;
1273 kvm
->arch
.model
.ibc
= proc
->ibc
;
1275 memcpy(kvm
->arch
.model
.fac_list
, proc
->fac_list
,
1276 S390_ARCH_FAC_LIST_SIZE_BYTE
);
1277 VM_EVENT(kvm
, 3, "SET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx",
1278 kvm
->arch
.model
.ibc
,
1279 kvm
->arch
.model
.cpuid
);
1280 VM_EVENT(kvm
, 3, "SET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx",
1281 kvm
->arch
.model
.fac_list
[0],
1282 kvm
->arch
.model
.fac_list
[1],
1283 kvm
->arch
.model
.fac_list
[2]);
1288 mutex_unlock(&kvm
->lock
);
1292 static int kvm_s390_set_processor_feat(struct kvm
*kvm
,
1293 struct kvm_device_attr
*attr
)
1295 struct kvm_s390_vm_cpu_feat data
;
1297 if (copy_from_user(&data
, (void __user
*)attr
->addr
, sizeof(data
)))
1299 if (!bitmap_subset((unsigned long *) data
.feat
,
1300 kvm_s390_available_cpu_feat
,
1301 KVM_S390_VM_CPU_FEAT_NR_BITS
))
1304 mutex_lock(&kvm
->lock
);
1305 if (kvm
->created_vcpus
) {
1306 mutex_unlock(&kvm
->lock
);
1309 bitmap_copy(kvm
->arch
.cpu_feat
, (unsigned long *) data
.feat
,
1310 KVM_S390_VM_CPU_FEAT_NR_BITS
);
1311 mutex_unlock(&kvm
->lock
);
1312 VM_EVENT(kvm
, 3, "SET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx",
1319 static int kvm_s390_set_processor_subfunc(struct kvm
*kvm
,
1320 struct kvm_device_attr
*attr
)
1322 mutex_lock(&kvm
->lock
);
1323 if (kvm
->created_vcpus
) {
1324 mutex_unlock(&kvm
->lock
);
1328 if (copy_from_user(&kvm
->arch
.model
.subfuncs
, (void __user
*)attr
->addr
,
1329 sizeof(struct kvm_s390_vm_cpu_subfunc
))) {
1330 mutex_unlock(&kvm
->lock
);
1333 mutex_unlock(&kvm
->lock
);
1335 VM_EVENT(kvm
, 3, "SET: guest PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1336 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.plo
)[0],
1337 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.plo
)[1],
1338 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.plo
)[2],
1339 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.plo
)[3]);
1340 VM_EVENT(kvm
, 3, "SET: guest PTFF subfunc 0x%16.16lx.%16.16lx",
1341 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.ptff
)[0],
1342 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.ptff
)[1]);
1343 VM_EVENT(kvm
, 3, "SET: guest KMAC subfunc 0x%16.16lx.%16.16lx",
1344 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmac
)[0],
1345 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmac
)[1]);
1346 VM_EVENT(kvm
, 3, "SET: guest KMC subfunc 0x%16.16lx.%16.16lx",
1347 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmc
)[0],
1348 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmc
)[1]);
1349 VM_EVENT(kvm
, 3, "SET: guest KM subfunc 0x%16.16lx.%16.16lx",
1350 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.km
)[0],
1351 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.km
)[1]);
1352 VM_EVENT(kvm
, 3, "SET: guest KIMD subfunc 0x%16.16lx.%16.16lx",
1353 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kimd
)[0],
1354 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kimd
)[1]);
1355 VM_EVENT(kvm
, 3, "SET: guest KLMD subfunc 0x%16.16lx.%16.16lx",
1356 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.klmd
)[0],
1357 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.klmd
)[1]);
1358 VM_EVENT(kvm
, 3, "SET: guest PCKMO subfunc 0x%16.16lx.%16.16lx",
1359 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.pckmo
)[0],
1360 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.pckmo
)[1]);
1361 VM_EVENT(kvm
, 3, "SET: guest KMCTR subfunc 0x%16.16lx.%16.16lx",
1362 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmctr
)[0],
1363 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmctr
)[1]);
1364 VM_EVENT(kvm
, 3, "SET: guest KMF subfunc 0x%16.16lx.%16.16lx",
1365 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmf
)[0],
1366 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmf
)[1]);
1367 VM_EVENT(kvm
, 3, "SET: guest KMO subfunc 0x%16.16lx.%16.16lx",
1368 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmo
)[0],
1369 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmo
)[1]);
1370 VM_EVENT(kvm
, 3, "SET: guest PCC subfunc 0x%16.16lx.%16.16lx",
1371 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.pcc
)[0],
1372 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.pcc
)[1]);
1373 VM_EVENT(kvm
, 3, "SET: guest PPNO subfunc 0x%16.16lx.%16.16lx",
1374 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.ppno
)[0],
1375 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.ppno
)[1]);
1376 VM_EVENT(kvm
, 3, "SET: guest KMA subfunc 0x%16.16lx.%16.16lx",
1377 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kma
)[0],
1378 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kma
)[1]);
1379 VM_EVENT(kvm
, 3, "SET: guest KDSA subfunc 0x%16.16lx.%16.16lx",
1380 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kdsa
)[0],
1381 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kdsa
)[1]);
1382 VM_EVENT(kvm
, 3, "SET: guest SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1383 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.sortl
)[0],
1384 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.sortl
)[1],
1385 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.sortl
)[2],
1386 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.sortl
)[3]);
1387 VM_EVENT(kvm
, 3, "SET: guest DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1388 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.dfltcc
)[0],
1389 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.dfltcc
)[1],
1390 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.dfltcc
)[2],
1391 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.dfltcc
)[3]);
1396 static int kvm_s390_set_cpu_model(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1400 switch (attr
->attr
) {
1401 case KVM_S390_VM_CPU_PROCESSOR
:
1402 ret
= kvm_s390_set_processor(kvm
, attr
);
1404 case KVM_S390_VM_CPU_PROCESSOR_FEAT
:
1405 ret
= kvm_s390_set_processor_feat(kvm
, attr
);
1407 case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC
:
1408 ret
= kvm_s390_set_processor_subfunc(kvm
, attr
);
1414 static int kvm_s390_get_processor(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1416 struct kvm_s390_vm_cpu_processor
*proc
;
1419 proc
= kzalloc(sizeof(*proc
), GFP_KERNEL
);
1424 proc
->cpuid
= kvm
->arch
.model
.cpuid
;
1425 proc
->ibc
= kvm
->arch
.model
.ibc
;
1426 memcpy(&proc
->fac_list
, kvm
->arch
.model
.fac_list
,
1427 S390_ARCH_FAC_LIST_SIZE_BYTE
);
1428 VM_EVENT(kvm
, 3, "GET: guest ibc: 0x%4.4x, guest cpuid: 0x%16.16llx",
1429 kvm
->arch
.model
.ibc
,
1430 kvm
->arch
.model
.cpuid
);
1431 VM_EVENT(kvm
, 3, "GET: guest faclist: 0x%16.16llx.%16.16llx.%16.16llx",
1432 kvm
->arch
.model
.fac_list
[0],
1433 kvm
->arch
.model
.fac_list
[1],
1434 kvm
->arch
.model
.fac_list
[2]);
1435 if (copy_to_user((void __user
*)attr
->addr
, proc
, sizeof(*proc
)))
1442 static int kvm_s390_get_machine(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1444 struct kvm_s390_vm_cpu_machine
*mach
;
1447 mach
= kzalloc(sizeof(*mach
), GFP_KERNEL
);
1452 get_cpu_id((struct cpuid
*) &mach
->cpuid
);
1453 mach
->ibc
= sclp
.ibc
;
1454 memcpy(&mach
->fac_mask
, kvm
->arch
.model
.fac_mask
,
1455 S390_ARCH_FAC_LIST_SIZE_BYTE
);
1456 memcpy((unsigned long *)&mach
->fac_list
, S390_lowcore
.stfle_fac_list
,
1457 sizeof(S390_lowcore
.stfle_fac_list
));
1458 VM_EVENT(kvm
, 3, "GET: host ibc: 0x%4.4x, host cpuid: 0x%16.16llx",
1459 kvm
->arch
.model
.ibc
,
1460 kvm
->arch
.model
.cpuid
);
1461 VM_EVENT(kvm
, 3, "GET: host facmask: 0x%16.16llx.%16.16llx.%16.16llx",
1465 VM_EVENT(kvm
, 3, "GET: host faclist: 0x%16.16llx.%16.16llx.%16.16llx",
1469 if (copy_to_user((void __user
*)attr
->addr
, mach
, sizeof(*mach
)))
1476 static int kvm_s390_get_processor_feat(struct kvm
*kvm
,
1477 struct kvm_device_attr
*attr
)
1479 struct kvm_s390_vm_cpu_feat data
;
1481 bitmap_copy((unsigned long *) data
.feat
, kvm
->arch
.cpu_feat
,
1482 KVM_S390_VM_CPU_FEAT_NR_BITS
);
1483 if (copy_to_user((void __user
*)attr
->addr
, &data
, sizeof(data
)))
1485 VM_EVENT(kvm
, 3, "GET: guest feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx",
1492 static int kvm_s390_get_machine_feat(struct kvm
*kvm
,
1493 struct kvm_device_attr
*attr
)
1495 struct kvm_s390_vm_cpu_feat data
;
1497 bitmap_copy((unsigned long *) data
.feat
,
1498 kvm_s390_available_cpu_feat
,
1499 KVM_S390_VM_CPU_FEAT_NR_BITS
);
1500 if (copy_to_user((void __user
*)attr
->addr
, &data
, sizeof(data
)))
1502 VM_EVENT(kvm
, 3, "GET: host feat: 0x%16.16llx.0x%16.16llx.0x%16.16llx",
1509 static int kvm_s390_get_processor_subfunc(struct kvm
*kvm
,
1510 struct kvm_device_attr
*attr
)
1512 if (copy_to_user((void __user
*)attr
->addr
, &kvm
->arch
.model
.subfuncs
,
1513 sizeof(struct kvm_s390_vm_cpu_subfunc
)))
1516 VM_EVENT(kvm
, 3, "GET: guest PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1517 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.plo
)[0],
1518 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.plo
)[1],
1519 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.plo
)[2],
1520 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.plo
)[3]);
1521 VM_EVENT(kvm
, 3, "GET: guest PTFF subfunc 0x%16.16lx.%16.16lx",
1522 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.ptff
)[0],
1523 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.ptff
)[1]);
1524 VM_EVENT(kvm
, 3, "GET: guest KMAC subfunc 0x%16.16lx.%16.16lx",
1525 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmac
)[0],
1526 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmac
)[1]);
1527 VM_EVENT(kvm
, 3, "GET: guest KMC subfunc 0x%16.16lx.%16.16lx",
1528 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmc
)[0],
1529 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmc
)[1]);
1530 VM_EVENT(kvm
, 3, "GET: guest KM subfunc 0x%16.16lx.%16.16lx",
1531 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.km
)[0],
1532 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.km
)[1]);
1533 VM_EVENT(kvm
, 3, "GET: guest KIMD subfunc 0x%16.16lx.%16.16lx",
1534 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kimd
)[0],
1535 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kimd
)[1]);
1536 VM_EVENT(kvm
, 3, "GET: guest KLMD subfunc 0x%16.16lx.%16.16lx",
1537 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.klmd
)[0],
1538 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.klmd
)[1]);
1539 VM_EVENT(kvm
, 3, "GET: guest PCKMO subfunc 0x%16.16lx.%16.16lx",
1540 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.pckmo
)[0],
1541 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.pckmo
)[1]);
1542 VM_EVENT(kvm
, 3, "GET: guest KMCTR subfunc 0x%16.16lx.%16.16lx",
1543 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmctr
)[0],
1544 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmctr
)[1]);
1545 VM_EVENT(kvm
, 3, "GET: guest KMF subfunc 0x%16.16lx.%16.16lx",
1546 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmf
)[0],
1547 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmf
)[1]);
1548 VM_EVENT(kvm
, 3, "GET: guest KMO subfunc 0x%16.16lx.%16.16lx",
1549 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmo
)[0],
1550 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kmo
)[1]);
1551 VM_EVENT(kvm
, 3, "GET: guest PCC subfunc 0x%16.16lx.%16.16lx",
1552 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.pcc
)[0],
1553 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.pcc
)[1]);
1554 VM_EVENT(kvm
, 3, "GET: guest PPNO subfunc 0x%16.16lx.%16.16lx",
1555 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.ppno
)[0],
1556 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.ppno
)[1]);
1557 VM_EVENT(kvm
, 3, "GET: guest KMA subfunc 0x%16.16lx.%16.16lx",
1558 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kma
)[0],
1559 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kma
)[1]);
1560 VM_EVENT(kvm
, 3, "GET: guest KDSA subfunc 0x%16.16lx.%16.16lx",
1561 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kdsa
)[0],
1562 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.kdsa
)[1]);
1563 VM_EVENT(kvm
, 3, "GET: guest SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1564 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.sortl
)[0],
1565 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.sortl
)[1],
1566 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.sortl
)[2],
1567 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.sortl
)[3]);
1568 VM_EVENT(kvm
, 3, "GET: guest DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1569 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.dfltcc
)[0],
1570 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.dfltcc
)[1],
1571 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.dfltcc
)[2],
1572 ((unsigned long *) &kvm
->arch
.model
.subfuncs
.dfltcc
)[3]);
1577 static int kvm_s390_get_machine_subfunc(struct kvm
*kvm
,
1578 struct kvm_device_attr
*attr
)
1580 if (copy_to_user((void __user
*)attr
->addr
, &kvm_s390_available_subfunc
,
1581 sizeof(struct kvm_s390_vm_cpu_subfunc
)))
1584 VM_EVENT(kvm
, 3, "GET: host PLO subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1585 ((unsigned long *) &kvm_s390_available_subfunc
.plo
)[0],
1586 ((unsigned long *) &kvm_s390_available_subfunc
.plo
)[1],
1587 ((unsigned long *) &kvm_s390_available_subfunc
.plo
)[2],
1588 ((unsigned long *) &kvm_s390_available_subfunc
.plo
)[3]);
1589 VM_EVENT(kvm
, 3, "GET: host PTFF subfunc 0x%16.16lx.%16.16lx",
1590 ((unsigned long *) &kvm_s390_available_subfunc
.ptff
)[0],
1591 ((unsigned long *) &kvm_s390_available_subfunc
.ptff
)[1]);
1592 VM_EVENT(kvm
, 3, "GET: host KMAC subfunc 0x%16.16lx.%16.16lx",
1593 ((unsigned long *) &kvm_s390_available_subfunc
.kmac
)[0],
1594 ((unsigned long *) &kvm_s390_available_subfunc
.kmac
)[1]);
1595 VM_EVENT(kvm
, 3, "GET: host KMC subfunc 0x%16.16lx.%16.16lx",
1596 ((unsigned long *) &kvm_s390_available_subfunc
.kmc
)[0],
1597 ((unsigned long *) &kvm_s390_available_subfunc
.kmc
)[1]);
1598 VM_EVENT(kvm
, 3, "GET: host KM subfunc 0x%16.16lx.%16.16lx",
1599 ((unsigned long *) &kvm_s390_available_subfunc
.km
)[0],
1600 ((unsigned long *) &kvm_s390_available_subfunc
.km
)[1]);
1601 VM_EVENT(kvm
, 3, "GET: host KIMD subfunc 0x%16.16lx.%16.16lx",
1602 ((unsigned long *) &kvm_s390_available_subfunc
.kimd
)[0],
1603 ((unsigned long *) &kvm_s390_available_subfunc
.kimd
)[1]);
1604 VM_EVENT(kvm
, 3, "GET: host KLMD subfunc 0x%16.16lx.%16.16lx",
1605 ((unsigned long *) &kvm_s390_available_subfunc
.klmd
)[0],
1606 ((unsigned long *) &kvm_s390_available_subfunc
.klmd
)[1]);
1607 VM_EVENT(kvm
, 3, "GET: host PCKMO subfunc 0x%16.16lx.%16.16lx",
1608 ((unsigned long *) &kvm_s390_available_subfunc
.pckmo
)[0],
1609 ((unsigned long *) &kvm_s390_available_subfunc
.pckmo
)[1]);
1610 VM_EVENT(kvm
, 3, "GET: host KMCTR subfunc 0x%16.16lx.%16.16lx",
1611 ((unsigned long *) &kvm_s390_available_subfunc
.kmctr
)[0],
1612 ((unsigned long *) &kvm_s390_available_subfunc
.kmctr
)[1]);
1613 VM_EVENT(kvm
, 3, "GET: host KMF subfunc 0x%16.16lx.%16.16lx",
1614 ((unsigned long *) &kvm_s390_available_subfunc
.kmf
)[0],
1615 ((unsigned long *) &kvm_s390_available_subfunc
.kmf
)[1]);
1616 VM_EVENT(kvm
, 3, "GET: host KMO subfunc 0x%16.16lx.%16.16lx",
1617 ((unsigned long *) &kvm_s390_available_subfunc
.kmo
)[0],
1618 ((unsigned long *) &kvm_s390_available_subfunc
.kmo
)[1]);
1619 VM_EVENT(kvm
, 3, "GET: host PCC subfunc 0x%16.16lx.%16.16lx",
1620 ((unsigned long *) &kvm_s390_available_subfunc
.pcc
)[0],
1621 ((unsigned long *) &kvm_s390_available_subfunc
.pcc
)[1]);
1622 VM_EVENT(kvm
, 3, "GET: host PPNO subfunc 0x%16.16lx.%16.16lx",
1623 ((unsigned long *) &kvm_s390_available_subfunc
.ppno
)[0],
1624 ((unsigned long *) &kvm_s390_available_subfunc
.ppno
)[1]);
1625 VM_EVENT(kvm
, 3, "GET: host KMA subfunc 0x%16.16lx.%16.16lx",
1626 ((unsigned long *) &kvm_s390_available_subfunc
.kma
)[0],
1627 ((unsigned long *) &kvm_s390_available_subfunc
.kma
)[1]);
1628 VM_EVENT(kvm
, 3, "GET: host KDSA subfunc 0x%16.16lx.%16.16lx",
1629 ((unsigned long *) &kvm_s390_available_subfunc
.kdsa
)[0],
1630 ((unsigned long *) &kvm_s390_available_subfunc
.kdsa
)[1]);
1631 VM_EVENT(kvm
, 3, "GET: host SORTL subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1632 ((unsigned long *) &kvm_s390_available_subfunc
.sortl
)[0],
1633 ((unsigned long *) &kvm_s390_available_subfunc
.sortl
)[1],
1634 ((unsigned long *) &kvm_s390_available_subfunc
.sortl
)[2],
1635 ((unsigned long *) &kvm_s390_available_subfunc
.sortl
)[3]);
1636 VM_EVENT(kvm
, 3, "GET: host DFLTCC subfunc 0x%16.16lx.%16.16lx.%16.16lx.%16.16lx",
1637 ((unsigned long *) &kvm_s390_available_subfunc
.dfltcc
)[0],
1638 ((unsigned long *) &kvm_s390_available_subfunc
.dfltcc
)[1],
1639 ((unsigned long *) &kvm_s390_available_subfunc
.dfltcc
)[2],
1640 ((unsigned long *) &kvm_s390_available_subfunc
.dfltcc
)[3]);
1645 static int kvm_s390_get_cpu_model(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1649 switch (attr
->attr
) {
1650 case KVM_S390_VM_CPU_PROCESSOR
:
1651 ret
= kvm_s390_get_processor(kvm
, attr
);
1653 case KVM_S390_VM_CPU_MACHINE
:
1654 ret
= kvm_s390_get_machine(kvm
, attr
);
1656 case KVM_S390_VM_CPU_PROCESSOR_FEAT
:
1657 ret
= kvm_s390_get_processor_feat(kvm
, attr
);
1659 case KVM_S390_VM_CPU_MACHINE_FEAT
:
1660 ret
= kvm_s390_get_machine_feat(kvm
, attr
);
1662 case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC
:
1663 ret
= kvm_s390_get_processor_subfunc(kvm
, attr
);
1665 case KVM_S390_VM_CPU_MACHINE_SUBFUNC
:
1666 ret
= kvm_s390_get_machine_subfunc(kvm
, attr
);
1672 static int kvm_s390_vm_set_attr(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1676 switch (attr
->group
) {
1677 case KVM_S390_VM_MEM_CTRL
:
1678 ret
= kvm_s390_set_mem_control(kvm
, attr
);
1680 case KVM_S390_VM_TOD
:
1681 ret
= kvm_s390_set_tod(kvm
, attr
);
1683 case KVM_S390_VM_CPU_MODEL
:
1684 ret
= kvm_s390_set_cpu_model(kvm
, attr
);
1686 case KVM_S390_VM_CRYPTO
:
1687 ret
= kvm_s390_vm_set_crypto(kvm
, attr
);
1689 case KVM_S390_VM_MIGRATION
:
1690 ret
= kvm_s390_vm_set_migration(kvm
, attr
);
1700 static int kvm_s390_vm_get_attr(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1704 switch (attr
->group
) {
1705 case KVM_S390_VM_MEM_CTRL
:
1706 ret
= kvm_s390_get_mem_control(kvm
, attr
);
1708 case KVM_S390_VM_TOD
:
1709 ret
= kvm_s390_get_tod(kvm
, attr
);
1711 case KVM_S390_VM_CPU_MODEL
:
1712 ret
= kvm_s390_get_cpu_model(kvm
, attr
);
1714 case KVM_S390_VM_MIGRATION
:
1715 ret
= kvm_s390_vm_get_migration(kvm
, attr
);
1725 static int kvm_s390_vm_has_attr(struct kvm
*kvm
, struct kvm_device_attr
*attr
)
1729 switch (attr
->group
) {
1730 case KVM_S390_VM_MEM_CTRL
:
1731 switch (attr
->attr
) {
1732 case KVM_S390_VM_MEM_ENABLE_CMMA
:
1733 case KVM_S390_VM_MEM_CLR_CMMA
:
1734 ret
= sclp
.has_cmma
? 0 : -ENXIO
;
1736 case KVM_S390_VM_MEM_LIMIT_SIZE
:
1744 case KVM_S390_VM_TOD
:
1745 switch (attr
->attr
) {
1746 case KVM_S390_VM_TOD_LOW
:
1747 case KVM_S390_VM_TOD_HIGH
:
1755 case KVM_S390_VM_CPU_MODEL
:
1756 switch (attr
->attr
) {
1757 case KVM_S390_VM_CPU_PROCESSOR
:
1758 case KVM_S390_VM_CPU_MACHINE
:
1759 case KVM_S390_VM_CPU_PROCESSOR_FEAT
:
1760 case KVM_S390_VM_CPU_MACHINE_FEAT
:
1761 case KVM_S390_VM_CPU_MACHINE_SUBFUNC
:
1762 case KVM_S390_VM_CPU_PROCESSOR_SUBFUNC
:
1770 case KVM_S390_VM_CRYPTO
:
1771 switch (attr
->attr
) {
1772 case KVM_S390_VM_CRYPTO_ENABLE_AES_KW
:
1773 case KVM_S390_VM_CRYPTO_ENABLE_DEA_KW
:
1774 case KVM_S390_VM_CRYPTO_DISABLE_AES_KW
:
1775 case KVM_S390_VM_CRYPTO_DISABLE_DEA_KW
:
1778 case KVM_S390_VM_CRYPTO_ENABLE_APIE
:
1779 case KVM_S390_VM_CRYPTO_DISABLE_APIE
:
1780 ret
= ap_instructions_available() ? 0 : -ENXIO
;
1787 case KVM_S390_VM_MIGRATION
:
1798 static long kvm_s390_get_skeys(struct kvm
*kvm
, struct kvm_s390_skeys
*args
)
1802 int srcu_idx
, i
, r
= 0;
1804 if (args
->flags
!= 0)
1807 /* Is this guest using storage keys? */
1808 if (!mm_uses_skeys(current
->mm
))
1809 return KVM_S390_GET_SKEYS_NONE
;
1811 /* Enforce sane limit on memory allocation */
1812 if (args
->count
< 1 || args
->count
> KVM_S390_SKEYS_MAX
)
1815 keys
= kvmalloc_array(args
->count
, sizeof(uint8_t), GFP_KERNEL
);
1819 down_read(¤t
->mm
->mmap_sem
);
1820 srcu_idx
= srcu_read_lock(&kvm
->srcu
);
1821 for (i
= 0; i
< args
->count
; i
++) {
1822 hva
= gfn_to_hva(kvm
, args
->start_gfn
+ i
);
1823 if (kvm_is_error_hva(hva
)) {
1828 r
= get_guest_storage_key(current
->mm
, hva
, &keys
[i
]);
1832 srcu_read_unlock(&kvm
->srcu
, srcu_idx
);
1833 up_read(¤t
->mm
->mmap_sem
);
1836 r
= copy_to_user((uint8_t __user
*)args
->skeydata_addr
, keys
,
1837 sizeof(uint8_t) * args
->count
);
1846 static long kvm_s390_set_skeys(struct kvm
*kvm
, struct kvm_s390_skeys
*args
)
1850 int srcu_idx
, i
, r
= 0;
1853 if (args
->flags
!= 0)
1856 /* Enforce sane limit on memory allocation */
1857 if (args
->count
< 1 || args
->count
> KVM_S390_SKEYS_MAX
)
1860 keys
= kvmalloc_array(args
->count
, sizeof(uint8_t), GFP_KERNEL
);
1864 r
= copy_from_user(keys
, (uint8_t __user
*)args
->skeydata_addr
,
1865 sizeof(uint8_t) * args
->count
);
1871 /* Enable storage key handling for the guest */
1872 r
= s390_enable_skey();
1877 down_read(¤t
->mm
->mmap_sem
);
1878 srcu_idx
= srcu_read_lock(&kvm
->srcu
);
1879 while (i
< args
->count
) {
1881 hva
= gfn_to_hva(kvm
, args
->start_gfn
+ i
);
1882 if (kvm_is_error_hva(hva
)) {
1887 /* Lowest order bit is reserved */
1888 if (keys
[i
] & 0x01) {
1893 r
= set_guest_storage_key(current
->mm
, hva
, keys
[i
], 0);
1895 r
= fixup_user_fault(current
, current
->mm
, hva
,
1896 FAULT_FLAG_WRITE
, &unlocked
);
1903 srcu_read_unlock(&kvm
->srcu
, srcu_idx
);
1904 up_read(¤t
->mm
->mmap_sem
);
1911 * Base address and length must be sent at the start of each block, therefore
1912 * it's cheaper to send some clean data, as long as it's less than the size of
1915 #define KVM_S390_MAX_BIT_DISTANCE (2 * sizeof(void *))
1916 /* for consistency */
1917 #define KVM_S390_CMMA_SIZE_MAX ((u32)KVM_S390_SKEYS_MAX)
1920 * Similar to gfn_to_memslot, but returns the index of a memslot also when the
1921 * address falls in a hole. In that case the index of one of the memslots
1922 * bordering the hole is returned.
1924 static int gfn_to_memslot_approx(struct kvm_memslots
*slots
, gfn_t gfn
)
1926 int start
= 0, end
= slots
->used_slots
;
1927 int slot
= atomic_read(&slots
->lru_slot
);
1928 struct kvm_memory_slot
*memslots
= slots
->memslots
;
1930 if (gfn
>= memslots
[slot
].base_gfn
&&
1931 gfn
< memslots
[slot
].base_gfn
+ memslots
[slot
].npages
)
1934 while (start
< end
) {
1935 slot
= start
+ (end
- start
) / 2;
1937 if (gfn
>= memslots
[slot
].base_gfn
)
1943 if (start
>= slots
->used_slots
)
1944 return slots
->used_slots
- 1;
1946 if (gfn
>= memslots
[start
].base_gfn
&&
1947 gfn
< memslots
[start
].base_gfn
+ memslots
[start
].npages
) {
1948 atomic_set(&slots
->lru_slot
, start
);
1954 static int kvm_s390_peek_cmma(struct kvm
*kvm
, struct kvm_s390_cmma_log
*args
,
1955 u8
*res
, unsigned long bufsize
)
1957 unsigned long pgstev
, hva
, cur_gfn
= args
->start_gfn
;
1960 while (args
->count
< bufsize
) {
1961 hva
= gfn_to_hva(kvm
, cur_gfn
);
1963 * We return an error if the first value was invalid, but we
1964 * return successfully if at least one value was copied.
1966 if (kvm_is_error_hva(hva
))
1967 return args
->count
? 0 : -EFAULT
;
1968 if (get_pgste(kvm
->mm
, hva
, &pgstev
) < 0)
1970 res
[args
->count
++] = (pgstev
>> 24) & 0x43;
1977 static unsigned long kvm_s390_next_dirty_cmma(struct kvm_memslots
*slots
,
1978 unsigned long cur_gfn
)
1980 int slotidx
= gfn_to_memslot_approx(slots
, cur_gfn
);
1981 struct kvm_memory_slot
*ms
= slots
->memslots
+ slotidx
;
1982 unsigned long ofs
= cur_gfn
- ms
->base_gfn
;
1984 if (ms
->base_gfn
+ ms
->npages
<= cur_gfn
) {
1986 /* If we are above the highest slot, wrap around */
1988 slotidx
= slots
->used_slots
- 1;
1990 ms
= slots
->memslots
+ slotidx
;
1993 ofs
= find_next_bit(kvm_second_dirty_bitmap(ms
), ms
->npages
, ofs
);
1994 while ((slotidx
> 0) && (ofs
>= ms
->npages
)) {
1996 ms
= slots
->memslots
+ slotidx
;
1997 ofs
= find_next_bit(kvm_second_dirty_bitmap(ms
), ms
->npages
, 0);
1999 return ms
->base_gfn
+ ofs
;
2002 static int kvm_s390_get_cmma(struct kvm
*kvm
, struct kvm_s390_cmma_log
*args
,
2003 u8
*res
, unsigned long bufsize
)
2005 unsigned long mem_end
, cur_gfn
, next_gfn
, hva
, pgstev
;
2006 struct kvm_memslots
*slots
= kvm_memslots(kvm
);
2007 struct kvm_memory_slot
*ms
;
2009 if (unlikely(!slots
->used_slots
))
2012 cur_gfn
= kvm_s390_next_dirty_cmma(slots
, args
->start_gfn
);
2013 ms
= gfn_to_memslot(kvm
, cur_gfn
);
2015 args
->start_gfn
= cur_gfn
;
2018 next_gfn
= kvm_s390_next_dirty_cmma(slots
, cur_gfn
+ 1);
2019 mem_end
= slots
->memslots
[0].base_gfn
+ slots
->memslots
[0].npages
;
2021 while (args
->count
< bufsize
) {
2022 hva
= gfn_to_hva(kvm
, cur_gfn
);
2023 if (kvm_is_error_hva(hva
))
2025 /* Decrement only if we actually flipped the bit to 0 */
2026 if (test_and_clear_bit(cur_gfn
- ms
->base_gfn
, kvm_second_dirty_bitmap(ms
)))
2027 atomic64_dec(&kvm
->arch
.cmma_dirty_pages
);
2028 if (get_pgste(kvm
->mm
, hva
, &pgstev
) < 0)
2030 /* Save the value */
2031 res
[args
->count
++] = (pgstev
>> 24) & 0x43;
2032 /* If the next bit is too far away, stop. */
2033 if (next_gfn
> cur_gfn
+ KVM_S390_MAX_BIT_DISTANCE
)
2035 /* If we reached the previous "next", find the next one */
2036 if (cur_gfn
== next_gfn
)
2037 next_gfn
= kvm_s390_next_dirty_cmma(slots
, cur_gfn
+ 1);
2038 /* Reached the end of memory or of the buffer, stop */
2039 if ((next_gfn
>= mem_end
) ||
2040 (next_gfn
- args
->start_gfn
>= bufsize
))
2043 /* Reached the end of the current memslot, take the next one. */
2044 if (cur_gfn
- ms
->base_gfn
>= ms
->npages
) {
2045 ms
= gfn_to_memslot(kvm
, cur_gfn
);
2054 * This function searches for the next page with dirty CMMA attributes, and
2055 * saves the attributes in the buffer up to either the end of the buffer or
2056 * until a block of at least KVM_S390_MAX_BIT_DISTANCE clean bits is found;
2057 * no trailing clean bytes are saved.
2058 * In case no dirty bits were found, or if CMMA was not enabled or used, the
2059 * output buffer will indicate 0 as length.
2061 static int kvm_s390_get_cmma_bits(struct kvm
*kvm
,
2062 struct kvm_s390_cmma_log
*args
)
2064 unsigned long bufsize
;
2065 int srcu_idx
, peek
, ret
;
2068 if (!kvm
->arch
.use_cmma
)
2070 /* Invalid/unsupported flags were specified */
2071 if (args
->flags
& ~KVM_S390_CMMA_PEEK
)
2073 /* Migration mode query, and we are not doing a migration */
2074 peek
= !!(args
->flags
& KVM_S390_CMMA_PEEK
);
2075 if (!peek
&& !kvm
->arch
.migration_mode
)
2077 /* CMMA is disabled or was not used, or the buffer has length zero */
2078 bufsize
= min(args
->count
, KVM_S390_CMMA_SIZE_MAX
);
2079 if (!bufsize
|| !kvm
->mm
->context
.uses_cmm
) {
2080 memset(args
, 0, sizeof(*args
));
2083 /* We are not peeking, and there are no dirty pages */
2084 if (!peek
&& !atomic64_read(&kvm
->arch
.cmma_dirty_pages
)) {
2085 memset(args
, 0, sizeof(*args
));
2089 values
= vmalloc(bufsize
);
2093 down_read(&kvm
->mm
->mmap_sem
);
2094 srcu_idx
= srcu_read_lock(&kvm
->srcu
);
2096 ret
= kvm_s390_peek_cmma(kvm
, args
, values
, bufsize
);
2098 ret
= kvm_s390_get_cmma(kvm
, args
, values
, bufsize
);
2099 srcu_read_unlock(&kvm
->srcu
, srcu_idx
);
2100 up_read(&kvm
->mm
->mmap_sem
);
2102 if (kvm
->arch
.migration_mode
)
2103 args
->remaining
= atomic64_read(&kvm
->arch
.cmma_dirty_pages
);
2105 args
->remaining
= 0;
2107 if (copy_to_user((void __user
*)args
->values
, values
, args
->count
))
2115 * This function sets the CMMA attributes for the given pages. If the input
2116 * buffer has zero length, no action is taken, otherwise the attributes are
2117 * set and the mm->context.uses_cmm flag is set.
2119 static int kvm_s390_set_cmma_bits(struct kvm
*kvm
,
2120 const struct kvm_s390_cmma_log
*args
)
2122 unsigned long hva
, mask
, pgstev
, i
;
2124 int srcu_idx
, r
= 0;
2128 if (!kvm
->arch
.use_cmma
)
2130 /* invalid/unsupported flags */
2131 if (args
->flags
!= 0)
2133 /* Enforce sane limit on memory allocation */
2134 if (args
->count
> KVM_S390_CMMA_SIZE_MAX
)
2137 if (args
->count
== 0)
2140 bits
= vmalloc(array_size(sizeof(*bits
), args
->count
));
2144 r
= copy_from_user(bits
, (void __user
*)args
->values
, args
->count
);
2150 down_read(&kvm
->mm
->mmap_sem
);
2151 srcu_idx
= srcu_read_lock(&kvm
->srcu
);
2152 for (i
= 0; i
< args
->count
; i
++) {
2153 hva
= gfn_to_hva(kvm
, args
->start_gfn
+ i
);
2154 if (kvm_is_error_hva(hva
)) {
2160 pgstev
= pgstev
<< 24;
2161 mask
&= _PGSTE_GPS_USAGE_MASK
| _PGSTE_GPS_NODAT
;
2162 set_pgste_bits(kvm
->mm
, hva
, mask
, pgstev
);
2164 srcu_read_unlock(&kvm
->srcu
, srcu_idx
);
2165 up_read(&kvm
->mm
->mmap_sem
);
2167 if (!kvm
->mm
->context
.uses_cmm
) {
2168 down_write(&kvm
->mm
->mmap_sem
);
2169 kvm
->mm
->context
.uses_cmm
= 1;
2170 up_write(&kvm
->mm
->mmap_sem
);
2177 static int kvm_s390_cpus_from_pv(struct kvm
*kvm
, u16
*rcp
, u16
*rrcp
)
2179 struct kvm_vcpu
*vcpu
;
2185 * We ignore failures and try to destroy as many CPUs as possible.
2186 * At the same time we must not free the assigned resources when
2187 * this fails, as the ultravisor has still access to that memory.
2188 * So kvm_s390_pv_destroy_cpu can leave a "wanted" memory leak
2190 * We want to return the first failure rc and rrc, though.
2192 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
2193 mutex_lock(&vcpu
->mutex
);
2194 if (kvm_s390_pv_destroy_cpu(vcpu
, &rc
, &rrc
) && !ret
) {
2199 mutex_unlock(&vcpu
->mutex
);
2204 static int kvm_s390_cpus_to_pv(struct kvm
*kvm
, u16
*rc
, u16
*rrc
)
2209 struct kvm_vcpu
*vcpu
;
2211 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
2212 mutex_lock(&vcpu
->mutex
);
2213 r
= kvm_s390_pv_create_cpu(vcpu
, rc
, rrc
);
2214 mutex_unlock(&vcpu
->mutex
);
2219 kvm_s390_cpus_from_pv(kvm
, &dummy
, &dummy
);
2223 static int kvm_s390_handle_pv(struct kvm
*kvm
, struct kvm_pv_cmd
*cmd
)
2227 void __user
*argp
= (void __user
*)cmd
->data
;
2230 case KVM_PV_ENABLE
: {
2232 if (kvm_s390_pv_is_protected(kvm
))
2236 * FMT 4 SIE needs esca. As we never switch back to bsca from
2237 * esca, we need no cleanup in the error cases below
2239 r
= sca_switch_to_extended(kvm
);
2243 down_write(¤t
->mm
->mmap_sem
);
2244 r
= gmap_mark_unmergeable();
2245 up_write(¤t
->mm
->mmap_sem
);
2249 r
= kvm_s390_pv_init_vm(kvm
, &cmd
->rc
, &cmd
->rrc
);
2253 r
= kvm_s390_cpus_to_pv(kvm
, &cmd
->rc
, &cmd
->rrc
);
2255 kvm_s390_pv_deinit_vm(kvm
, &dummy
, &dummy
);
2257 /* we need to block service interrupts from now on */
2258 set_bit(IRQ_PEND_EXT_SERVICE
, &kvm
->arch
.float_int
.masked_irqs
);
2261 case KVM_PV_DISABLE
: {
2263 if (!kvm_s390_pv_is_protected(kvm
))
2266 r
= kvm_s390_cpus_from_pv(kvm
, &cmd
->rc
, &cmd
->rrc
);
2268 * If a CPU could not be destroyed, destroy VM will also fail.
2269 * There is no point in trying to destroy it. Instead return
2270 * the rc and rrc from the first CPU that failed destroying.
2274 r
= kvm_s390_pv_deinit_vm(kvm
, &cmd
->rc
, &cmd
->rrc
);
2276 /* no need to block service interrupts any more */
2277 clear_bit(IRQ_PEND_EXT_SERVICE
, &kvm
->arch
.float_int
.masked_irqs
);
2280 case KVM_PV_SET_SEC_PARMS
: {
2281 struct kvm_s390_pv_sec_parm parms
= {};
2285 if (!kvm_s390_pv_is_protected(kvm
))
2289 if (copy_from_user(&parms
, argp
, sizeof(parms
)))
2292 /* Currently restricted to 8KB */
2294 if (parms
.length
> PAGE_SIZE
* 2)
2298 hdr
= vmalloc(parms
.length
);
2303 if (!copy_from_user(hdr
, (void __user
*)parms
.origin
,
2305 r
= kvm_s390_pv_set_sec_parms(kvm
, hdr
, parms
.length
,
2306 &cmd
->rc
, &cmd
->rrc
);
2311 case KVM_PV_UNPACK
: {
2312 struct kvm_s390_pv_unp unp
= {};
2315 if (!kvm_s390_pv_is_protected(kvm
))
2319 if (copy_from_user(&unp
, argp
, sizeof(unp
)))
2322 r
= kvm_s390_pv_unpack(kvm
, unp
.addr
, unp
.size
, unp
.tweak
,
2323 &cmd
->rc
, &cmd
->rrc
);
2326 case KVM_PV_VERIFY
: {
2328 if (!kvm_s390_pv_is_protected(kvm
))
2331 r
= uv_cmd_nodata(kvm_s390_pv_get_handle(kvm
),
2332 UVC_CMD_VERIFY_IMG
, &cmd
->rc
, &cmd
->rrc
);
2333 KVM_UV_EVENT(kvm
, 3, "PROTVIRT VERIFY: rc %x rrc %x", cmd
->rc
,
2337 case KVM_PV_PREP_RESET
: {
2339 if (!kvm_s390_pv_is_protected(kvm
))
2342 r
= uv_cmd_nodata(kvm_s390_pv_get_handle(kvm
),
2343 UVC_CMD_PREPARE_RESET
, &cmd
->rc
, &cmd
->rrc
);
2344 KVM_UV_EVENT(kvm
, 3, "PROTVIRT PREP RESET: rc %x rrc %x",
2348 case KVM_PV_UNSHARE_ALL
: {
2350 if (!kvm_s390_pv_is_protected(kvm
))
2353 r
= uv_cmd_nodata(kvm_s390_pv_get_handle(kvm
),
2354 UVC_CMD_SET_UNSHARE_ALL
, &cmd
->rc
, &cmd
->rrc
);
2355 KVM_UV_EVENT(kvm
, 3, "PROTVIRT UNSHARE: rc %x rrc %x",
2365 long kvm_arch_vm_ioctl(struct file
*filp
,
2366 unsigned int ioctl
, unsigned long arg
)
2368 struct kvm
*kvm
= filp
->private_data
;
2369 void __user
*argp
= (void __user
*)arg
;
2370 struct kvm_device_attr attr
;
2374 case KVM_S390_INTERRUPT
: {
2375 struct kvm_s390_interrupt s390int
;
2378 if (copy_from_user(&s390int
, argp
, sizeof(s390int
)))
2380 r
= kvm_s390_inject_vm(kvm
, &s390int
);
2383 case KVM_CREATE_IRQCHIP
: {
2384 struct kvm_irq_routing_entry routing
;
2387 if (kvm
->arch
.use_irqchip
) {
2388 /* Set up dummy routing. */
2389 memset(&routing
, 0, sizeof(routing
));
2390 r
= kvm_set_irq_routing(kvm
, &routing
, 0, 0);
2394 case KVM_SET_DEVICE_ATTR
: {
2396 if (copy_from_user(&attr
, (void __user
*)arg
, sizeof(attr
)))
2398 r
= kvm_s390_vm_set_attr(kvm
, &attr
);
2401 case KVM_GET_DEVICE_ATTR
: {
2403 if (copy_from_user(&attr
, (void __user
*)arg
, sizeof(attr
)))
2405 r
= kvm_s390_vm_get_attr(kvm
, &attr
);
2408 case KVM_HAS_DEVICE_ATTR
: {
2410 if (copy_from_user(&attr
, (void __user
*)arg
, sizeof(attr
)))
2412 r
= kvm_s390_vm_has_attr(kvm
, &attr
);
2415 case KVM_S390_GET_SKEYS
: {
2416 struct kvm_s390_skeys args
;
2419 if (copy_from_user(&args
, argp
,
2420 sizeof(struct kvm_s390_skeys
)))
2422 r
= kvm_s390_get_skeys(kvm
, &args
);
2425 case KVM_S390_SET_SKEYS
: {
2426 struct kvm_s390_skeys args
;
2429 if (copy_from_user(&args
, argp
,
2430 sizeof(struct kvm_s390_skeys
)))
2432 r
= kvm_s390_set_skeys(kvm
, &args
);
2435 case KVM_S390_GET_CMMA_BITS
: {
2436 struct kvm_s390_cmma_log args
;
2439 if (copy_from_user(&args
, argp
, sizeof(args
)))
2441 mutex_lock(&kvm
->slots_lock
);
2442 r
= kvm_s390_get_cmma_bits(kvm
, &args
);
2443 mutex_unlock(&kvm
->slots_lock
);
2445 r
= copy_to_user(argp
, &args
, sizeof(args
));
2451 case KVM_S390_SET_CMMA_BITS
: {
2452 struct kvm_s390_cmma_log args
;
2455 if (copy_from_user(&args
, argp
, sizeof(args
)))
2457 mutex_lock(&kvm
->slots_lock
);
2458 r
= kvm_s390_set_cmma_bits(kvm
, &args
);
2459 mutex_unlock(&kvm
->slots_lock
);
2462 case KVM_S390_PV_COMMAND
: {
2463 struct kvm_pv_cmd args
;
2465 /* protvirt means user sigp */
2466 kvm
->arch
.user_cpu_state_ctrl
= 1;
2468 if (!is_prot_virt_host()) {
2472 if (copy_from_user(&args
, argp
, sizeof(args
))) {
2480 mutex_lock(&kvm
->lock
);
2481 r
= kvm_s390_handle_pv(kvm
, &args
);
2482 mutex_unlock(&kvm
->lock
);
2483 if (copy_to_user(argp
, &args
, sizeof(args
))) {
2496 static int kvm_s390_apxa_installed(void)
2498 struct ap_config_info info
;
2500 if (ap_instructions_available()) {
2501 if (ap_qci(&info
) == 0)
2509 * The format of the crypto control block (CRYCB) is specified in the 3 low
2510 * order bits of the CRYCB designation (CRYCBD) field as follows:
2511 * Format 0: Neither the message security assist extension 3 (MSAX3) nor the
2512 * AP extended addressing (APXA) facility are installed.
2513 * Format 1: The APXA facility is not installed but the MSAX3 facility is.
2514 * Format 2: Both the APXA and MSAX3 facilities are installed
2516 static void kvm_s390_set_crycb_format(struct kvm
*kvm
)
2518 kvm
->arch
.crypto
.crycbd
= (__u32
)(unsigned long) kvm
->arch
.crypto
.crycb
;
2520 /* Clear the CRYCB format bits - i.e., set format 0 by default */
2521 kvm
->arch
.crypto
.crycbd
&= ~(CRYCB_FORMAT_MASK
);
2523 /* Check whether MSAX3 is installed */
2524 if (!test_kvm_facility(kvm
, 76))
2527 if (kvm_s390_apxa_installed())
2528 kvm
->arch
.crypto
.crycbd
|= CRYCB_FORMAT2
;
2530 kvm
->arch
.crypto
.crycbd
|= CRYCB_FORMAT1
;
2533 void kvm_arch_crypto_set_masks(struct kvm
*kvm
, unsigned long *apm
,
2534 unsigned long *aqm
, unsigned long *adm
)
2536 struct kvm_s390_crypto_cb
*crycb
= kvm
->arch
.crypto
.crycb
;
2538 mutex_lock(&kvm
->lock
);
2539 kvm_s390_vcpu_block_all(kvm
);
2541 switch (kvm
->arch
.crypto
.crycbd
& CRYCB_FORMAT_MASK
) {
2542 case CRYCB_FORMAT2
: /* APCB1 use 256 bits */
2543 memcpy(crycb
->apcb1
.apm
, apm
, 32);
2544 VM_EVENT(kvm
, 3, "SET CRYCB: apm %016lx %016lx %016lx %016lx",
2545 apm
[0], apm
[1], apm
[2], apm
[3]);
2546 memcpy(crycb
->apcb1
.aqm
, aqm
, 32);
2547 VM_EVENT(kvm
, 3, "SET CRYCB: aqm %016lx %016lx %016lx %016lx",
2548 aqm
[0], aqm
[1], aqm
[2], aqm
[3]);
2549 memcpy(crycb
->apcb1
.adm
, adm
, 32);
2550 VM_EVENT(kvm
, 3, "SET CRYCB: adm %016lx %016lx %016lx %016lx",
2551 adm
[0], adm
[1], adm
[2], adm
[3]);
2554 case CRYCB_FORMAT0
: /* Fall through both use APCB0 */
2555 memcpy(crycb
->apcb0
.apm
, apm
, 8);
2556 memcpy(crycb
->apcb0
.aqm
, aqm
, 2);
2557 memcpy(crycb
->apcb0
.adm
, adm
, 2);
2558 VM_EVENT(kvm
, 3, "SET CRYCB: apm %016lx aqm %04x adm %04x",
2559 apm
[0], *((unsigned short *)aqm
),
2560 *((unsigned short *)adm
));
2562 default: /* Can not happen */
2566 /* recreate the shadow crycb for each vcpu */
2567 kvm_s390_sync_request_broadcast(kvm
, KVM_REQ_VSIE_RESTART
);
2568 kvm_s390_vcpu_unblock_all(kvm
);
2569 mutex_unlock(&kvm
->lock
);
2571 EXPORT_SYMBOL_GPL(kvm_arch_crypto_set_masks
);
2573 void kvm_arch_crypto_clear_masks(struct kvm
*kvm
)
2575 mutex_lock(&kvm
->lock
);
2576 kvm_s390_vcpu_block_all(kvm
);
2578 memset(&kvm
->arch
.crypto
.crycb
->apcb0
, 0,
2579 sizeof(kvm
->arch
.crypto
.crycb
->apcb0
));
2580 memset(&kvm
->arch
.crypto
.crycb
->apcb1
, 0,
2581 sizeof(kvm
->arch
.crypto
.crycb
->apcb1
));
2583 VM_EVENT(kvm
, 3, "%s", "CLR CRYCB:");
2584 /* recreate the shadow crycb for each vcpu */
2585 kvm_s390_sync_request_broadcast(kvm
, KVM_REQ_VSIE_RESTART
);
2586 kvm_s390_vcpu_unblock_all(kvm
);
2587 mutex_unlock(&kvm
->lock
);
2589 EXPORT_SYMBOL_GPL(kvm_arch_crypto_clear_masks
);
2591 static u64
kvm_s390_get_initial_cpuid(void)
2596 cpuid
.version
= 0xff;
2597 return *((u64
*) &cpuid
);
2600 static void kvm_s390_crypto_init(struct kvm
*kvm
)
2602 kvm
->arch
.crypto
.crycb
= &kvm
->arch
.sie_page2
->crycb
;
2603 kvm_s390_set_crycb_format(kvm
);
2605 if (!test_kvm_facility(kvm
, 76))
2608 /* Enable AES/DEA protected key functions by default */
2609 kvm
->arch
.crypto
.aes_kw
= 1;
2610 kvm
->arch
.crypto
.dea_kw
= 1;
2611 get_random_bytes(kvm
->arch
.crypto
.crycb
->aes_wrapping_key_mask
,
2612 sizeof(kvm
->arch
.crypto
.crycb
->aes_wrapping_key_mask
));
2613 get_random_bytes(kvm
->arch
.crypto
.crycb
->dea_wrapping_key_mask
,
2614 sizeof(kvm
->arch
.crypto
.crycb
->dea_wrapping_key_mask
));
2617 static void sca_dispose(struct kvm
*kvm
)
2619 if (kvm
->arch
.use_esca
)
2620 free_pages_exact(kvm
->arch
.sca
, sizeof(struct esca_block
));
2622 free_page((unsigned long)(kvm
->arch
.sca
));
2623 kvm
->arch
.sca
= NULL
;
2626 int kvm_arch_init_vm(struct kvm
*kvm
, unsigned long type
)
2628 gfp_t alloc_flags
= GFP_KERNEL
;
2630 char debug_name
[16];
2631 static unsigned long sca_offset
;
2634 #ifdef CONFIG_KVM_S390_UCONTROL
2635 if (type
& ~KVM_VM_S390_UCONTROL
)
2637 if ((type
& KVM_VM_S390_UCONTROL
) && (!capable(CAP_SYS_ADMIN
)))
2644 rc
= s390_enable_sie();
2650 if (!sclp
.has_64bscao
)
2651 alloc_flags
|= GFP_DMA
;
2652 rwlock_init(&kvm
->arch
.sca_lock
);
2653 /* start with basic SCA */
2654 kvm
->arch
.sca
= (struct bsca_block
*) get_zeroed_page(alloc_flags
);
2657 mutex_lock(&kvm_lock
);
2659 if (sca_offset
+ sizeof(struct bsca_block
) > PAGE_SIZE
)
2661 kvm
->arch
.sca
= (struct bsca_block
*)
2662 ((char *) kvm
->arch
.sca
+ sca_offset
);
2663 mutex_unlock(&kvm_lock
);
2665 sprintf(debug_name
, "kvm-%u", current
->pid
);
2667 kvm
->arch
.dbf
= debug_register(debug_name
, 32, 1, 7 * sizeof(long));
2671 BUILD_BUG_ON(sizeof(struct sie_page2
) != 4096);
2672 kvm
->arch
.sie_page2
=
2673 (struct sie_page2
*) get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
2674 if (!kvm
->arch
.sie_page2
)
2677 kvm
->arch
.sie_page2
->kvm
= kvm
;
2678 kvm
->arch
.model
.fac_list
= kvm
->arch
.sie_page2
->fac_list
;
2680 for (i
= 0; i
< kvm_s390_fac_size(); i
++) {
2681 kvm
->arch
.model
.fac_mask
[i
] = S390_lowcore
.stfle_fac_list
[i
] &
2682 (kvm_s390_fac_base
[i
] |
2683 kvm_s390_fac_ext
[i
]);
2684 kvm
->arch
.model
.fac_list
[i
] = S390_lowcore
.stfle_fac_list
[i
] &
2685 kvm_s390_fac_base
[i
];
2687 kvm
->arch
.model
.subfuncs
= kvm_s390_available_subfunc
;
2689 /* we are always in czam mode - even on pre z14 machines */
2690 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 138);
2691 set_kvm_facility(kvm
->arch
.model
.fac_list
, 138);
2692 /* we emulate STHYI in kvm */
2693 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 74);
2694 set_kvm_facility(kvm
->arch
.model
.fac_list
, 74);
2695 if (MACHINE_HAS_TLB_GUEST
) {
2696 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 147);
2697 set_kvm_facility(kvm
->arch
.model
.fac_list
, 147);
2700 if (css_general_characteristics
.aiv
&& test_facility(65))
2701 set_kvm_facility(kvm
->arch
.model
.fac_mask
, 65);
2703 kvm
->arch
.model
.cpuid
= kvm_s390_get_initial_cpuid();
2704 kvm
->arch
.model
.ibc
= sclp
.ibc
& 0x0fff;
2706 kvm_s390_crypto_init(kvm
);
2708 mutex_init(&kvm
->arch
.float_int
.ais_lock
);
2709 spin_lock_init(&kvm
->arch
.float_int
.lock
);
2710 for (i
= 0; i
< FIRQ_LIST_COUNT
; i
++)
2711 INIT_LIST_HEAD(&kvm
->arch
.float_int
.lists
[i
]);
2712 init_waitqueue_head(&kvm
->arch
.ipte_wq
);
2713 mutex_init(&kvm
->arch
.ipte_mutex
);
2715 debug_register_view(kvm
->arch
.dbf
, &debug_sprintf_view
);
2716 VM_EVENT(kvm
, 3, "vm created with type %lu", type
);
2718 if (type
& KVM_VM_S390_UCONTROL
) {
2719 kvm
->arch
.gmap
= NULL
;
2720 kvm
->arch
.mem_limit
= KVM_S390_NO_MEM_LIMIT
;
2722 if (sclp
.hamax
== U64_MAX
)
2723 kvm
->arch
.mem_limit
= TASK_SIZE_MAX
;
2725 kvm
->arch
.mem_limit
= min_t(unsigned long, TASK_SIZE_MAX
,
2727 kvm
->arch
.gmap
= gmap_create(current
->mm
, kvm
->arch
.mem_limit
- 1);
2728 if (!kvm
->arch
.gmap
)
2730 kvm
->arch
.gmap
->private = kvm
;
2731 kvm
->arch
.gmap
->pfault_enabled
= 0;
2734 kvm
->arch
.use_pfmfi
= sclp
.has_pfmfi
;
2735 kvm
->arch
.use_skf
= sclp
.has_skey
;
2736 spin_lock_init(&kvm
->arch
.start_stop_lock
);
2737 kvm_s390_vsie_init(kvm
);
2739 kvm_s390_gisa_init(kvm
);
2740 KVM_EVENT(3, "vm 0x%pK created by pid %u", kvm
, current
->pid
);
2744 free_page((unsigned long)kvm
->arch
.sie_page2
);
2745 debug_unregister(kvm
->arch
.dbf
);
2747 KVM_EVENT(3, "creation of vm failed: %d", rc
);
2751 void kvm_arch_vcpu_destroy(struct kvm_vcpu
*vcpu
)
2755 VCPU_EVENT(vcpu
, 3, "%s", "free cpu");
2756 trace_kvm_s390_destroy_vcpu(vcpu
->vcpu_id
);
2757 kvm_s390_clear_local_irqs(vcpu
);
2758 kvm_clear_async_pf_completion_queue(vcpu
);
2759 if (!kvm_is_ucontrol(vcpu
->kvm
))
2762 if (kvm_is_ucontrol(vcpu
->kvm
))
2763 gmap_remove(vcpu
->arch
.gmap
);
2765 if (vcpu
->kvm
->arch
.use_cmma
)
2766 kvm_s390_vcpu_unsetup_cmma(vcpu
);
2767 /* We can not hold the vcpu mutex here, we are already dying */
2768 if (kvm_s390_pv_cpu_get_handle(vcpu
))
2769 kvm_s390_pv_destroy_cpu(vcpu
, &rc
, &rrc
);
2770 free_page((unsigned long)(vcpu
->arch
.sie_block
));
2773 static void kvm_free_vcpus(struct kvm
*kvm
)
2776 struct kvm_vcpu
*vcpu
;
2778 kvm_for_each_vcpu(i
, vcpu
, kvm
)
2779 kvm_vcpu_destroy(vcpu
);
2781 mutex_lock(&kvm
->lock
);
2782 for (i
= 0; i
< atomic_read(&kvm
->online_vcpus
); i
++)
2783 kvm
->vcpus
[i
] = NULL
;
2785 atomic_set(&kvm
->online_vcpus
, 0);
2786 mutex_unlock(&kvm
->lock
);
2789 void kvm_arch_destroy_vm(struct kvm
*kvm
)
2793 kvm_free_vcpus(kvm
);
2795 kvm_s390_gisa_destroy(kvm
);
2797 * We are already at the end of life and kvm->lock is not taken.
2798 * This is ok as the file descriptor is closed by now and nobody
2799 * can mess with the pv state. To avoid lockdep_assert_held from
2800 * complaining we do not use kvm_s390_pv_is_protected.
2802 if (kvm_s390_pv_get_handle(kvm
))
2803 kvm_s390_pv_deinit_vm(kvm
, &rc
, &rrc
);
2804 debug_unregister(kvm
->arch
.dbf
);
2805 free_page((unsigned long)kvm
->arch
.sie_page2
);
2806 if (!kvm_is_ucontrol(kvm
))
2807 gmap_remove(kvm
->arch
.gmap
);
2808 kvm_s390_destroy_adapters(kvm
);
2809 kvm_s390_clear_float_irqs(kvm
);
2810 kvm_s390_vsie_destroy(kvm
);
2811 KVM_EVENT(3, "vm 0x%pK destroyed", kvm
);
2814 /* Section: vcpu related */
2815 static int __kvm_ucontrol_vcpu_init(struct kvm_vcpu
*vcpu
)
2817 vcpu
->arch
.gmap
= gmap_create(current
->mm
, -1UL);
2818 if (!vcpu
->arch
.gmap
)
2820 vcpu
->arch
.gmap
->private = vcpu
->kvm
;
2825 static void sca_del_vcpu(struct kvm_vcpu
*vcpu
)
2827 if (!kvm_s390_use_sca_entries())
2829 read_lock(&vcpu
->kvm
->arch
.sca_lock
);
2830 if (vcpu
->kvm
->arch
.use_esca
) {
2831 struct esca_block
*sca
= vcpu
->kvm
->arch
.sca
;
2833 clear_bit_inv(vcpu
->vcpu_id
, (unsigned long *) sca
->mcn
);
2834 sca
->cpu
[vcpu
->vcpu_id
].sda
= 0;
2836 struct bsca_block
*sca
= vcpu
->kvm
->arch
.sca
;
2838 clear_bit_inv(vcpu
->vcpu_id
, (unsigned long *) &sca
->mcn
);
2839 sca
->cpu
[vcpu
->vcpu_id
].sda
= 0;
2841 read_unlock(&vcpu
->kvm
->arch
.sca_lock
);
2844 static void sca_add_vcpu(struct kvm_vcpu
*vcpu
)
2846 if (!kvm_s390_use_sca_entries()) {
2847 struct bsca_block
*sca
= vcpu
->kvm
->arch
.sca
;
2849 /* we still need the basic sca for the ipte control */
2850 vcpu
->arch
.sie_block
->scaoh
= (__u32
)(((__u64
)sca
) >> 32);
2851 vcpu
->arch
.sie_block
->scaol
= (__u32
)(__u64
)sca
;
2854 read_lock(&vcpu
->kvm
->arch
.sca_lock
);
2855 if (vcpu
->kvm
->arch
.use_esca
) {
2856 struct esca_block
*sca
= vcpu
->kvm
->arch
.sca
;
2858 sca
->cpu
[vcpu
->vcpu_id
].sda
= (__u64
) vcpu
->arch
.sie_block
;
2859 vcpu
->arch
.sie_block
->scaoh
= (__u32
)(((__u64
)sca
) >> 32);
2860 vcpu
->arch
.sie_block
->scaol
= (__u32
)(__u64
)sca
& ~0x3fU
;
2861 vcpu
->arch
.sie_block
->ecb2
|= ECB2_ESCA
;
2862 set_bit_inv(vcpu
->vcpu_id
, (unsigned long *) sca
->mcn
);
2864 struct bsca_block
*sca
= vcpu
->kvm
->arch
.sca
;
2866 sca
->cpu
[vcpu
->vcpu_id
].sda
= (__u64
) vcpu
->arch
.sie_block
;
2867 vcpu
->arch
.sie_block
->scaoh
= (__u32
)(((__u64
)sca
) >> 32);
2868 vcpu
->arch
.sie_block
->scaol
= (__u32
)(__u64
)sca
;
2869 set_bit_inv(vcpu
->vcpu_id
, (unsigned long *) &sca
->mcn
);
2871 read_unlock(&vcpu
->kvm
->arch
.sca_lock
);
2874 /* Basic SCA to Extended SCA data copy routines */
2875 static inline void sca_copy_entry(struct esca_entry
*d
, struct bsca_entry
*s
)
2878 d
->sigp_ctrl
.c
= s
->sigp_ctrl
.c
;
2879 d
->sigp_ctrl
.scn
= s
->sigp_ctrl
.scn
;
2882 static void sca_copy_b_to_e(struct esca_block
*d
, struct bsca_block
*s
)
2886 d
->ipte_control
= s
->ipte_control
;
2888 for (i
= 0; i
< KVM_S390_BSCA_CPU_SLOTS
; i
++)
2889 sca_copy_entry(&d
->cpu
[i
], &s
->cpu
[i
]);
2892 static int sca_switch_to_extended(struct kvm
*kvm
)
2894 struct bsca_block
*old_sca
= kvm
->arch
.sca
;
2895 struct esca_block
*new_sca
;
2896 struct kvm_vcpu
*vcpu
;
2897 unsigned int vcpu_idx
;
2900 if (kvm
->arch
.use_esca
)
2903 new_sca
= alloc_pages_exact(sizeof(*new_sca
), GFP_KERNEL
|__GFP_ZERO
);
2907 scaoh
= (u32
)((u64
)(new_sca
) >> 32);
2908 scaol
= (u32
)(u64
)(new_sca
) & ~0x3fU
;
2910 kvm_s390_vcpu_block_all(kvm
);
2911 write_lock(&kvm
->arch
.sca_lock
);
2913 sca_copy_b_to_e(new_sca
, old_sca
);
2915 kvm_for_each_vcpu(vcpu_idx
, vcpu
, kvm
) {
2916 vcpu
->arch
.sie_block
->scaoh
= scaoh
;
2917 vcpu
->arch
.sie_block
->scaol
= scaol
;
2918 vcpu
->arch
.sie_block
->ecb2
|= ECB2_ESCA
;
2920 kvm
->arch
.sca
= new_sca
;
2921 kvm
->arch
.use_esca
= 1;
2923 write_unlock(&kvm
->arch
.sca_lock
);
2924 kvm_s390_vcpu_unblock_all(kvm
);
2926 free_page((unsigned long)old_sca
);
2928 VM_EVENT(kvm
, 2, "Switched to ESCA (0x%pK -> 0x%pK)",
2929 old_sca
, kvm
->arch
.sca
);
2933 static int sca_can_add_vcpu(struct kvm
*kvm
, unsigned int id
)
2937 if (!kvm_s390_use_sca_entries()) {
2938 if (id
< KVM_MAX_VCPUS
)
2942 if (id
< KVM_S390_BSCA_CPU_SLOTS
)
2944 if (!sclp
.has_esca
|| !sclp
.has_64bscao
)
2947 mutex_lock(&kvm
->lock
);
2948 rc
= kvm
->arch
.use_esca
? 0 : sca_switch_to_extended(kvm
);
2949 mutex_unlock(&kvm
->lock
);
2951 return rc
== 0 && id
< KVM_S390_ESCA_CPU_SLOTS
;
2954 /* needs disabled preemption to protect from TOD sync and vcpu_load/put */
2955 static void __start_cpu_timer_accounting(struct kvm_vcpu
*vcpu
)
2957 WARN_ON_ONCE(vcpu
->arch
.cputm_start
!= 0);
2958 raw_write_seqcount_begin(&vcpu
->arch
.cputm_seqcount
);
2959 vcpu
->arch
.cputm_start
= get_tod_clock_fast();
2960 raw_write_seqcount_end(&vcpu
->arch
.cputm_seqcount
);
2963 /* needs disabled preemption to protect from TOD sync and vcpu_load/put */
2964 static void __stop_cpu_timer_accounting(struct kvm_vcpu
*vcpu
)
2966 WARN_ON_ONCE(vcpu
->arch
.cputm_start
== 0);
2967 raw_write_seqcount_begin(&vcpu
->arch
.cputm_seqcount
);
2968 vcpu
->arch
.sie_block
->cputm
-= get_tod_clock_fast() - vcpu
->arch
.cputm_start
;
2969 vcpu
->arch
.cputm_start
= 0;
2970 raw_write_seqcount_end(&vcpu
->arch
.cputm_seqcount
);
2973 /* needs disabled preemption to protect from TOD sync and vcpu_load/put */
2974 static void __enable_cpu_timer_accounting(struct kvm_vcpu
*vcpu
)
2976 WARN_ON_ONCE(vcpu
->arch
.cputm_enabled
);
2977 vcpu
->arch
.cputm_enabled
= true;
2978 __start_cpu_timer_accounting(vcpu
);
2981 /* needs disabled preemption to protect from TOD sync and vcpu_load/put */
2982 static void __disable_cpu_timer_accounting(struct kvm_vcpu
*vcpu
)
2984 WARN_ON_ONCE(!vcpu
->arch
.cputm_enabled
);
2985 __stop_cpu_timer_accounting(vcpu
);
2986 vcpu
->arch
.cputm_enabled
= false;
2989 static void enable_cpu_timer_accounting(struct kvm_vcpu
*vcpu
)
2991 preempt_disable(); /* protect from TOD sync and vcpu_load/put */
2992 __enable_cpu_timer_accounting(vcpu
);
2996 static void disable_cpu_timer_accounting(struct kvm_vcpu
*vcpu
)
2998 preempt_disable(); /* protect from TOD sync and vcpu_load/put */
2999 __disable_cpu_timer_accounting(vcpu
);
3003 /* set the cpu timer - may only be called from the VCPU thread itself */
3004 void kvm_s390_set_cpu_timer(struct kvm_vcpu
*vcpu
, __u64 cputm
)
3006 preempt_disable(); /* protect from TOD sync and vcpu_load/put */
3007 raw_write_seqcount_begin(&vcpu
->arch
.cputm_seqcount
);
3008 if (vcpu
->arch
.cputm_enabled
)
3009 vcpu
->arch
.cputm_start
= get_tod_clock_fast();
3010 vcpu
->arch
.sie_block
->cputm
= cputm
;
3011 raw_write_seqcount_end(&vcpu
->arch
.cputm_seqcount
);
3015 /* update and get the cpu timer - can also be called from other VCPU threads */
3016 __u64
kvm_s390_get_cpu_timer(struct kvm_vcpu
*vcpu
)
3021 if (unlikely(!vcpu
->arch
.cputm_enabled
))
3022 return vcpu
->arch
.sie_block
->cputm
;
3024 preempt_disable(); /* protect from TOD sync and vcpu_load/put */
3026 seq
= raw_read_seqcount(&vcpu
->arch
.cputm_seqcount
);
3028 * If the writer would ever execute a read in the critical
3029 * section, e.g. in irq context, we have a deadlock.
3031 WARN_ON_ONCE((seq
& 1) && smp_processor_id() == vcpu
->cpu
);
3032 value
= vcpu
->arch
.sie_block
->cputm
;
3033 /* if cputm_start is 0, accounting is being started/stopped */
3034 if (likely(vcpu
->arch
.cputm_start
))
3035 value
-= get_tod_clock_fast() - vcpu
->arch
.cputm_start
;
3036 } while (read_seqcount_retry(&vcpu
->arch
.cputm_seqcount
, seq
& ~1));
3041 void kvm_arch_vcpu_load(struct kvm_vcpu
*vcpu
, int cpu
)
3044 gmap_enable(vcpu
->arch
.enabled_gmap
);
3045 kvm_s390_set_cpuflags(vcpu
, CPUSTAT_RUNNING
);
3046 if (vcpu
->arch
.cputm_enabled
&& !is_vcpu_idle(vcpu
))
3047 __start_cpu_timer_accounting(vcpu
);
3051 void kvm_arch_vcpu_put(struct kvm_vcpu
*vcpu
)
3054 if (vcpu
->arch
.cputm_enabled
&& !is_vcpu_idle(vcpu
))
3055 __stop_cpu_timer_accounting(vcpu
);
3056 kvm_s390_clear_cpuflags(vcpu
, CPUSTAT_RUNNING
);
3057 vcpu
->arch
.enabled_gmap
= gmap_get_enabled();
3058 gmap_disable(vcpu
->arch
.enabled_gmap
);
3062 void kvm_arch_vcpu_postcreate(struct kvm_vcpu
*vcpu
)
3064 mutex_lock(&vcpu
->kvm
->lock
);
3066 vcpu
->arch
.sie_block
->epoch
= vcpu
->kvm
->arch
.epoch
;
3067 vcpu
->arch
.sie_block
->epdx
= vcpu
->kvm
->arch
.epdx
;
3069 mutex_unlock(&vcpu
->kvm
->lock
);
3070 if (!kvm_is_ucontrol(vcpu
->kvm
)) {
3071 vcpu
->arch
.gmap
= vcpu
->kvm
->arch
.gmap
;
3074 if (test_kvm_facility(vcpu
->kvm
, 74) || vcpu
->kvm
->arch
.user_instr0
)
3075 vcpu
->arch
.sie_block
->ictl
|= ICTL_OPEREXC
;
3076 /* make vcpu_load load the right gmap on the first trigger */
3077 vcpu
->arch
.enabled_gmap
= vcpu
->arch
.gmap
;
3080 static bool kvm_has_pckmo_subfunc(struct kvm
*kvm
, unsigned long nr
)
3082 if (test_bit_inv(nr
, (unsigned long *)&kvm
->arch
.model
.subfuncs
.pckmo
) &&
3083 test_bit_inv(nr
, (unsigned long *)&kvm_s390_available_subfunc
.pckmo
))
3088 static bool kvm_has_pckmo_ecc(struct kvm
*kvm
)
3090 /* At least one ECC subfunction must be present */
3091 return kvm_has_pckmo_subfunc(kvm
, 32) ||
3092 kvm_has_pckmo_subfunc(kvm
, 33) ||
3093 kvm_has_pckmo_subfunc(kvm
, 34) ||
3094 kvm_has_pckmo_subfunc(kvm
, 40) ||
3095 kvm_has_pckmo_subfunc(kvm
, 41);
3099 static void kvm_s390_vcpu_crypto_setup(struct kvm_vcpu
*vcpu
)
3102 * If the AP instructions are not being interpreted and the MSAX3
3103 * facility is not configured for the guest, there is nothing to set up.
3105 if (!vcpu
->kvm
->arch
.crypto
.apie
&& !test_kvm_facility(vcpu
->kvm
, 76))
3108 vcpu
->arch
.sie_block
->crycbd
= vcpu
->kvm
->arch
.crypto
.crycbd
;
3109 vcpu
->arch
.sie_block
->ecb3
&= ~(ECB3_AES
| ECB3_DEA
);
3110 vcpu
->arch
.sie_block
->eca
&= ~ECA_APIE
;
3111 vcpu
->arch
.sie_block
->ecd
&= ~ECD_ECC
;
3113 if (vcpu
->kvm
->arch
.crypto
.apie
)
3114 vcpu
->arch
.sie_block
->eca
|= ECA_APIE
;
3116 /* Set up protected key support */
3117 if (vcpu
->kvm
->arch
.crypto
.aes_kw
) {
3118 vcpu
->arch
.sie_block
->ecb3
|= ECB3_AES
;
3119 /* ecc is also wrapped with AES key */
3120 if (kvm_has_pckmo_ecc(vcpu
->kvm
))
3121 vcpu
->arch
.sie_block
->ecd
|= ECD_ECC
;
3124 if (vcpu
->kvm
->arch
.crypto
.dea_kw
)
3125 vcpu
->arch
.sie_block
->ecb3
|= ECB3_DEA
;
3128 void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu
*vcpu
)
3130 free_page(vcpu
->arch
.sie_block
->cbrlo
);
3131 vcpu
->arch
.sie_block
->cbrlo
= 0;
3134 int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu
*vcpu
)
3136 vcpu
->arch
.sie_block
->cbrlo
= get_zeroed_page(GFP_KERNEL
);
3137 if (!vcpu
->arch
.sie_block
->cbrlo
)
3142 static void kvm_s390_vcpu_setup_model(struct kvm_vcpu
*vcpu
)
3144 struct kvm_s390_cpu_model
*model
= &vcpu
->kvm
->arch
.model
;
3146 vcpu
->arch
.sie_block
->ibc
= model
->ibc
;
3147 if (test_kvm_facility(vcpu
->kvm
, 7))
3148 vcpu
->arch
.sie_block
->fac
= (u32
)(u64
) model
->fac_list
;
3151 static int kvm_s390_vcpu_setup(struct kvm_vcpu
*vcpu
)
3156 atomic_set(&vcpu
->arch
.sie_block
->cpuflags
, CPUSTAT_ZARCH
|
3160 if (test_kvm_facility(vcpu
->kvm
, 78))
3161 kvm_s390_set_cpuflags(vcpu
, CPUSTAT_GED2
);
3162 else if (test_kvm_facility(vcpu
->kvm
, 8))
3163 kvm_s390_set_cpuflags(vcpu
, CPUSTAT_GED
);
3165 kvm_s390_vcpu_setup_model(vcpu
);
3167 /* pgste_set_pte has special handling for !MACHINE_HAS_ESOP */
3168 if (MACHINE_HAS_ESOP
)
3169 vcpu
->arch
.sie_block
->ecb
|= ECB_HOSTPROTINT
;
3170 if (test_kvm_facility(vcpu
->kvm
, 9))
3171 vcpu
->arch
.sie_block
->ecb
|= ECB_SRSI
;
3172 if (test_kvm_facility(vcpu
->kvm
, 73))
3173 vcpu
->arch
.sie_block
->ecb
|= ECB_TE
;
3175 if (test_kvm_facility(vcpu
->kvm
, 8) && vcpu
->kvm
->arch
.use_pfmfi
)
3176 vcpu
->arch
.sie_block
->ecb2
|= ECB2_PFMFI
;
3177 if (test_kvm_facility(vcpu
->kvm
, 130))
3178 vcpu
->arch
.sie_block
->ecb2
|= ECB2_IEP
;
3179 vcpu
->arch
.sie_block
->eca
= ECA_MVPGI
| ECA_PROTEXCI
;
3181 vcpu
->arch
.sie_block
->eca
|= ECA_CEI
;
3183 vcpu
->arch
.sie_block
->eca
|= ECA_IB
;
3185 vcpu
->arch
.sie_block
->eca
|= ECA_SII
;
3186 if (sclp
.has_sigpif
)
3187 vcpu
->arch
.sie_block
->eca
|= ECA_SIGPI
;
3188 if (test_kvm_facility(vcpu
->kvm
, 129)) {
3189 vcpu
->arch
.sie_block
->eca
|= ECA_VX
;
3190 vcpu
->arch
.sie_block
->ecd
|= ECD_HOSTREGMGMT
;
3192 if (test_kvm_facility(vcpu
->kvm
, 139))
3193 vcpu
->arch
.sie_block
->ecd
|= ECD_MEF
;
3194 if (test_kvm_facility(vcpu
->kvm
, 156))
3195 vcpu
->arch
.sie_block
->ecd
|= ECD_ETOKENF
;
3196 if (vcpu
->arch
.sie_block
->gd
) {
3197 vcpu
->arch
.sie_block
->eca
|= ECA_AIV
;
3198 VCPU_EVENT(vcpu
, 3, "AIV gisa format-%u enabled for cpu %03u",
3199 vcpu
->arch
.sie_block
->gd
& 0x3, vcpu
->vcpu_id
);
3201 vcpu
->arch
.sie_block
->sdnxo
= ((unsigned long) &vcpu
->run
->s
.regs
.sdnx
)
3203 vcpu
->arch
.sie_block
->riccbd
= (unsigned long) &vcpu
->run
->s
.regs
.riccb
;
3206 kvm_s390_set_cpuflags(vcpu
, CPUSTAT_KSS
);
3208 vcpu
->arch
.sie_block
->ictl
|= ICTL_ISKE
| ICTL_SSKE
| ICTL_RRBE
;
3210 if (vcpu
->kvm
->arch
.use_cmma
) {
3211 rc
= kvm_s390_vcpu_setup_cmma(vcpu
);
3215 hrtimer_init(&vcpu
->arch
.ckc_timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL
);
3216 vcpu
->arch
.ckc_timer
.function
= kvm_s390_idle_wakeup
;
3218 vcpu
->arch
.sie_block
->hpid
= HPID_KVM
;
3220 kvm_s390_vcpu_crypto_setup(vcpu
);
3222 mutex_lock(&vcpu
->kvm
->lock
);
3223 if (kvm_s390_pv_is_protected(vcpu
->kvm
)) {
3224 rc
= kvm_s390_pv_create_cpu(vcpu
, &uvrc
, &uvrrc
);
3226 kvm_s390_vcpu_unsetup_cmma(vcpu
);
3228 mutex_unlock(&vcpu
->kvm
->lock
);
3233 int kvm_arch_vcpu_precreate(struct kvm
*kvm
, unsigned int id
)
3235 if (!kvm_is_ucontrol(kvm
) && !sca_can_add_vcpu(kvm
, id
))
3240 int kvm_arch_vcpu_create(struct kvm_vcpu
*vcpu
)
3242 struct sie_page
*sie_page
;
3245 BUILD_BUG_ON(sizeof(struct sie_page
) != 4096);
3246 sie_page
= (struct sie_page
*) get_zeroed_page(GFP_KERNEL
);
3250 vcpu
->arch
.sie_block
= &sie_page
->sie_block
;
3251 vcpu
->arch
.sie_block
->itdba
= (unsigned long) &sie_page
->itdb
;
3253 /* the real guest size will always be smaller than msl */
3254 vcpu
->arch
.sie_block
->mso
= 0;
3255 vcpu
->arch
.sie_block
->msl
= sclp
.hamax
;
3257 vcpu
->arch
.sie_block
->icpua
= vcpu
->vcpu_id
;
3258 spin_lock_init(&vcpu
->arch
.local_int
.lock
);
3259 vcpu
->arch
.sie_block
->gd
= (u32
)(u64
)vcpu
->kvm
->arch
.gisa_int
.origin
;
3260 if (vcpu
->arch
.sie_block
->gd
&& sclp
.has_gisaf
)
3261 vcpu
->arch
.sie_block
->gd
|= GISA_FORMAT1
;
3262 seqcount_init(&vcpu
->arch
.cputm_seqcount
);
3264 vcpu
->arch
.pfault_token
= KVM_S390_PFAULT_TOKEN_INVALID
;
3265 kvm_clear_async_pf_completion_queue(vcpu
);
3266 vcpu
->run
->kvm_valid_regs
= KVM_SYNC_PREFIX
|
3272 kvm_s390_set_prefix(vcpu
, 0);
3273 if (test_kvm_facility(vcpu
->kvm
, 64))
3274 vcpu
->run
->kvm_valid_regs
|= KVM_SYNC_RICCB
;
3275 if (test_kvm_facility(vcpu
->kvm
, 82))
3276 vcpu
->run
->kvm_valid_regs
|= KVM_SYNC_BPBC
;
3277 if (test_kvm_facility(vcpu
->kvm
, 133))
3278 vcpu
->run
->kvm_valid_regs
|= KVM_SYNC_GSCB
;
3279 if (test_kvm_facility(vcpu
->kvm
, 156))
3280 vcpu
->run
->kvm_valid_regs
|= KVM_SYNC_ETOKEN
;
3281 /* fprs can be synchronized via vrs, even if the guest has no vx. With
3282 * MACHINE_HAS_VX, (load|store)_fpu_regs() will work with vrs format.
3285 vcpu
->run
->kvm_valid_regs
|= KVM_SYNC_VRS
;
3287 vcpu
->run
->kvm_valid_regs
|= KVM_SYNC_FPRS
;
3289 if (kvm_is_ucontrol(vcpu
->kvm
)) {
3290 rc
= __kvm_ucontrol_vcpu_init(vcpu
);
3292 goto out_free_sie_block
;
3295 VM_EVENT(vcpu
->kvm
, 3, "create cpu %d at 0x%pK, sie block at 0x%pK",
3296 vcpu
->vcpu_id
, vcpu
, vcpu
->arch
.sie_block
);
3297 trace_kvm_s390_create_vcpu(vcpu
->vcpu_id
, vcpu
, vcpu
->arch
.sie_block
);
3299 rc
= kvm_s390_vcpu_setup(vcpu
);
3301 goto out_ucontrol_uninit
;
3304 out_ucontrol_uninit
:
3305 if (kvm_is_ucontrol(vcpu
->kvm
))
3306 gmap_remove(vcpu
->arch
.gmap
);
3308 free_page((unsigned long)(vcpu
->arch
.sie_block
));
3312 int kvm_arch_vcpu_runnable(struct kvm_vcpu
*vcpu
)
3314 return kvm_s390_vcpu_has_irq(vcpu
, 0);
3317 bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu
*vcpu
)
3319 return !(vcpu
->arch
.sie_block
->gpsw
.mask
& PSW_MASK_PSTATE
);
3322 void kvm_s390_vcpu_block(struct kvm_vcpu
*vcpu
)
3324 atomic_or(PROG_BLOCK_SIE
, &vcpu
->arch
.sie_block
->prog20
);
3328 void kvm_s390_vcpu_unblock(struct kvm_vcpu
*vcpu
)
3330 atomic_andnot(PROG_BLOCK_SIE
, &vcpu
->arch
.sie_block
->prog20
);
3333 static void kvm_s390_vcpu_request(struct kvm_vcpu
*vcpu
)
3335 atomic_or(PROG_REQUEST
, &vcpu
->arch
.sie_block
->prog20
);
3339 bool kvm_s390_vcpu_sie_inhibited(struct kvm_vcpu
*vcpu
)
3341 return atomic_read(&vcpu
->arch
.sie_block
->prog20
) &
3342 (PROG_BLOCK_SIE
| PROG_REQUEST
);
3345 static void kvm_s390_vcpu_request_handled(struct kvm_vcpu
*vcpu
)
3347 atomic_andnot(PROG_REQUEST
, &vcpu
->arch
.sie_block
->prog20
);
3351 * Kick a guest cpu out of (v)SIE and wait until (v)SIE is not running.
3352 * If the CPU is not running (e.g. waiting as idle) the function will
3353 * return immediately. */
3354 void exit_sie(struct kvm_vcpu
*vcpu
)
3356 kvm_s390_set_cpuflags(vcpu
, CPUSTAT_STOP_INT
);
3357 kvm_s390_vsie_kick(vcpu
);
3358 while (vcpu
->arch
.sie_block
->prog0c
& PROG_IN_SIE
)
3362 /* Kick a guest cpu out of SIE to process a request synchronously */
3363 void kvm_s390_sync_request(int req
, struct kvm_vcpu
*vcpu
)
3365 kvm_make_request(req
, vcpu
);
3366 kvm_s390_vcpu_request(vcpu
);
3369 static void kvm_gmap_notifier(struct gmap
*gmap
, unsigned long start
,
3372 struct kvm
*kvm
= gmap
->private;
3373 struct kvm_vcpu
*vcpu
;
3374 unsigned long prefix
;
3377 if (gmap_is_shadow(gmap
))
3379 if (start
>= 1UL << 31)
3380 /* We are only interested in prefix pages */
3382 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
3383 /* match against both prefix pages */
3384 prefix
= kvm_s390_get_prefix(vcpu
);
3385 if (prefix
<= end
&& start
<= prefix
+ 2*PAGE_SIZE
- 1) {
3386 VCPU_EVENT(vcpu
, 2, "gmap notifier for %lx-%lx",
3388 kvm_s390_sync_request(KVM_REQ_MMU_RELOAD
, vcpu
);
3393 bool kvm_arch_no_poll(struct kvm_vcpu
*vcpu
)
3395 /* do not poll with more than halt_poll_max_steal percent of steal time */
3396 if (S390_lowcore
.avg_steal_timer
* 100 / (TICK_USEC
<< 12) >=
3397 halt_poll_max_steal
) {
3398 vcpu
->stat
.halt_no_poll_steal
++;
3404 int kvm_arch_vcpu_should_kick(struct kvm_vcpu
*vcpu
)
3406 /* kvm common code refers to this, but never calls it */
3411 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu
*vcpu
,
3412 struct kvm_one_reg
*reg
)
3417 case KVM_REG_S390_TODPR
:
3418 r
= put_user(vcpu
->arch
.sie_block
->todpr
,
3419 (u32 __user
*)reg
->addr
);
3421 case KVM_REG_S390_EPOCHDIFF
:
3422 r
= put_user(vcpu
->arch
.sie_block
->epoch
,
3423 (u64 __user
*)reg
->addr
);
3425 case KVM_REG_S390_CPU_TIMER
:
3426 r
= put_user(kvm_s390_get_cpu_timer(vcpu
),
3427 (u64 __user
*)reg
->addr
);
3429 case KVM_REG_S390_CLOCK_COMP
:
3430 r
= put_user(vcpu
->arch
.sie_block
->ckc
,
3431 (u64 __user
*)reg
->addr
);
3433 case KVM_REG_S390_PFTOKEN
:
3434 r
= put_user(vcpu
->arch
.pfault_token
,
3435 (u64 __user
*)reg
->addr
);
3437 case KVM_REG_S390_PFCOMPARE
:
3438 r
= put_user(vcpu
->arch
.pfault_compare
,
3439 (u64 __user
*)reg
->addr
);
3441 case KVM_REG_S390_PFSELECT
:
3442 r
= put_user(vcpu
->arch
.pfault_select
,
3443 (u64 __user
*)reg
->addr
);
3445 case KVM_REG_S390_PP
:
3446 r
= put_user(vcpu
->arch
.sie_block
->pp
,
3447 (u64 __user
*)reg
->addr
);
3449 case KVM_REG_S390_GBEA
:
3450 r
= put_user(vcpu
->arch
.sie_block
->gbea
,
3451 (u64 __user
*)reg
->addr
);
3460 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu
*vcpu
,
3461 struct kvm_one_reg
*reg
)
3467 case KVM_REG_S390_TODPR
:
3468 r
= get_user(vcpu
->arch
.sie_block
->todpr
,
3469 (u32 __user
*)reg
->addr
);
3471 case KVM_REG_S390_EPOCHDIFF
:
3472 r
= get_user(vcpu
->arch
.sie_block
->epoch
,
3473 (u64 __user
*)reg
->addr
);
3475 case KVM_REG_S390_CPU_TIMER
:
3476 r
= get_user(val
, (u64 __user
*)reg
->addr
);
3478 kvm_s390_set_cpu_timer(vcpu
, val
);
3480 case KVM_REG_S390_CLOCK_COMP
:
3481 r
= get_user(vcpu
->arch
.sie_block
->ckc
,
3482 (u64 __user
*)reg
->addr
);
3484 case KVM_REG_S390_PFTOKEN
:
3485 r
= get_user(vcpu
->arch
.pfault_token
,
3486 (u64 __user
*)reg
->addr
);
3487 if (vcpu
->arch
.pfault_token
== KVM_S390_PFAULT_TOKEN_INVALID
)
3488 kvm_clear_async_pf_completion_queue(vcpu
);
3490 case KVM_REG_S390_PFCOMPARE
:
3491 r
= get_user(vcpu
->arch
.pfault_compare
,
3492 (u64 __user
*)reg
->addr
);
3494 case KVM_REG_S390_PFSELECT
:
3495 r
= get_user(vcpu
->arch
.pfault_select
,
3496 (u64 __user
*)reg
->addr
);
3498 case KVM_REG_S390_PP
:
3499 r
= get_user(vcpu
->arch
.sie_block
->pp
,
3500 (u64 __user
*)reg
->addr
);
3502 case KVM_REG_S390_GBEA
:
3503 r
= get_user(vcpu
->arch
.sie_block
->gbea
,
3504 (u64 __user
*)reg
->addr
);
3513 static void kvm_arch_vcpu_ioctl_normal_reset(struct kvm_vcpu
*vcpu
)
3515 vcpu
->arch
.sie_block
->gpsw
.mask
&= ~PSW_MASK_RI
;
3516 vcpu
->arch
.pfault_token
= KVM_S390_PFAULT_TOKEN_INVALID
;
3517 memset(vcpu
->run
->s
.regs
.riccb
, 0, sizeof(vcpu
->run
->s
.regs
.riccb
));
3519 kvm_clear_async_pf_completion_queue(vcpu
);
3520 if (!kvm_s390_user_cpu_state_ctrl(vcpu
->kvm
))
3521 kvm_s390_vcpu_stop(vcpu
);
3522 kvm_s390_clear_local_irqs(vcpu
);
3525 static void kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu
*vcpu
)
3527 /* Initial reset is a superset of the normal reset */
3528 kvm_arch_vcpu_ioctl_normal_reset(vcpu
);
3531 * This equals initial cpu reset in pop, but we don't switch to ESA.
3532 * We do not only reset the internal data, but also ...
3534 vcpu
->arch
.sie_block
->gpsw
.mask
= 0;
3535 vcpu
->arch
.sie_block
->gpsw
.addr
= 0;
3536 kvm_s390_set_prefix(vcpu
, 0);
3537 kvm_s390_set_cpu_timer(vcpu
, 0);
3538 vcpu
->arch
.sie_block
->ckc
= 0;
3539 memset(vcpu
->arch
.sie_block
->gcr
, 0, sizeof(vcpu
->arch
.sie_block
->gcr
));
3540 vcpu
->arch
.sie_block
->gcr
[0] = CR0_INITIAL_MASK
;
3541 vcpu
->arch
.sie_block
->gcr
[14] = CR14_INITIAL_MASK
;
3543 /* ... the data in sync regs */
3544 memset(vcpu
->run
->s
.regs
.crs
, 0, sizeof(vcpu
->run
->s
.regs
.crs
));
3545 vcpu
->run
->s
.regs
.ckc
= 0;
3546 vcpu
->run
->s
.regs
.crs
[0] = CR0_INITIAL_MASK
;
3547 vcpu
->run
->s
.regs
.crs
[14] = CR14_INITIAL_MASK
;
3548 vcpu
->run
->psw_addr
= 0;
3549 vcpu
->run
->psw_mask
= 0;
3550 vcpu
->run
->s
.regs
.todpr
= 0;
3551 vcpu
->run
->s
.regs
.cputm
= 0;
3552 vcpu
->run
->s
.regs
.ckc
= 0;
3553 vcpu
->run
->s
.regs
.pp
= 0;
3554 vcpu
->run
->s
.regs
.gbea
= 1;
3555 vcpu
->run
->s
.regs
.fpc
= 0;
3557 * Do not reset these registers in the protected case, as some of
3558 * them are overlayed and they are not accessible in this case
3561 if (!kvm_s390_pv_cpu_is_protected(vcpu
)) {
3562 vcpu
->arch
.sie_block
->gbea
= 1;
3563 vcpu
->arch
.sie_block
->pp
= 0;
3564 vcpu
->arch
.sie_block
->fpf
&= ~FPF_BPBC
;
3565 vcpu
->arch
.sie_block
->todpr
= 0;
3569 static void kvm_arch_vcpu_ioctl_clear_reset(struct kvm_vcpu
*vcpu
)
3571 struct kvm_sync_regs
*regs
= &vcpu
->run
->s
.regs
;
3573 /* Clear reset is a superset of the initial reset */
3574 kvm_arch_vcpu_ioctl_initial_reset(vcpu
);
3576 memset(®s
->gprs
, 0, sizeof(regs
->gprs
));
3577 memset(®s
->vrs
, 0, sizeof(regs
->vrs
));
3578 memset(®s
->acrs
, 0, sizeof(regs
->acrs
));
3579 memset(®s
->gscb
, 0, sizeof(regs
->gscb
));
3582 regs
->etoken_extension
= 0;
3585 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu
*vcpu
, struct kvm_regs
*regs
)
3588 memcpy(&vcpu
->run
->s
.regs
.gprs
, ®s
->gprs
, sizeof(regs
->gprs
));
3593 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu
*vcpu
, struct kvm_regs
*regs
)
3596 memcpy(®s
->gprs
, &vcpu
->run
->s
.regs
.gprs
, sizeof(regs
->gprs
));
3601 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu
*vcpu
,
3602 struct kvm_sregs
*sregs
)
3606 memcpy(&vcpu
->run
->s
.regs
.acrs
, &sregs
->acrs
, sizeof(sregs
->acrs
));
3607 memcpy(&vcpu
->arch
.sie_block
->gcr
, &sregs
->crs
, sizeof(sregs
->crs
));
3613 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu
*vcpu
,
3614 struct kvm_sregs
*sregs
)
3618 memcpy(&sregs
->acrs
, &vcpu
->run
->s
.regs
.acrs
, sizeof(sregs
->acrs
));
3619 memcpy(&sregs
->crs
, &vcpu
->arch
.sie_block
->gcr
, sizeof(sregs
->crs
));
3625 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu
*vcpu
, struct kvm_fpu
*fpu
)
3631 if (test_fp_ctl(fpu
->fpc
)) {
3635 vcpu
->run
->s
.regs
.fpc
= fpu
->fpc
;
3637 convert_fp_to_vx((__vector128
*) vcpu
->run
->s
.regs
.vrs
,
3638 (freg_t
*) fpu
->fprs
);
3640 memcpy(vcpu
->run
->s
.regs
.fprs
, &fpu
->fprs
, sizeof(fpu
->fprs
));
3647 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu
*vcpu
, struct kvm_fpu
*fpu
)
3651 /* make sure we have the latest values */
3654 convert_vx_to_fp((freg_t
*) fpu
->fprs
,
3655 (__vector128
*) vcpu
->run
->s
.regs
.vrs
);
3657 memcpy(fpu
->fprs
, vcpu
->run
->s
.regs
.fprs
, sizeof(fpu
->fprs
));
3658 fpu
->fpc
= vcpu
->run
->s
.regs
.fpc
;
3664 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu
*vcpu
, psw_t psw
)
3668 if (!is_vcpu_stopped(vcpu
))
3671 vcpu
->run
->psw_mask
= psw
.mask
;
3672 vcpu
->run
->psw_addr
= psw
.addr
;
3677 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu
*vcpu
,
3678 struct kvm_translation
*tr
)
3680 return -EINVAL
; /* not implemented yet */
3683 #define VALID_GUESTDBG_FLAGS (KVM_GUESTDBG_SINGLESTEP | \
3684 KVM_GUESTDBG_USE_HW_BP | \
3685 KVM_GUESTDBG_ENABLE)
3687 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu
*vcpu
,
3688 struct kvm_guest_debug
*dbg
)
3694 vcpu
->guest_debug
= 0;
3695 kvm_s390_clear_bp_data(vcpu
);
3697 if (dbg
->control
& ~VALID_GUESTDBG_FLAGS
) {
3701 if (!sclp
.has_gpere
) {
3706 if (dbg
->control
& KVM_GUESTDBG_ENABLE
) {
3707 vcpu
->guest_debug
= dbg
->control
;
3708 /* enforce guest PER */
3709 kvm_s390_set_cpuflags(vcpu
, CPUSTAT_P
);
3711 if (dbg
->control
& KVM_GUESTDBG_USE_HW_BP
)
3712 rc
= kvm_s390_import_bp_data(vcpu
, dbg
);
3714 kvm_s390_clear_cpuflags(vcpu
, CPUSTAT_P
);
3715 vcpu
->arch
.guestdbg
.last_bp
= 0;
3719 vcpu
->guest_debug
= 0;
3720 kvm_s390_clear_bp_data(vcpu
);
3721 kvm_s390_clear_cpuflags(vcpu
, CPUSTAT_P
);
3729 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu
*vcpu
,
3730 struct kvm_mp_state
*mp_state
)
3736 /* CHECK_STOP and LOAD are not supported yet */
3737 ret
= is_vcpu_stopped(vcpu
) ? KVM_MP_STATE_STOPPED
:
3738 KVM_MP_STATE_OPERATING
;
3744 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu
*vcpu
,
3745 struct kvm_mp_state
*mp_state
)
3751 /* user space knows about this interface - let it control the state */
3752 vcpu
->kvm
->arch
.user_cpu_state_ctrl
= 1;
3754 switch (mp_state
->mp_state
) {
3755 case KVM_MP_STATE_STOPPED
:
3756 rc
= kvm_s390_vcpu_stop(vcpu
);
3758 case KVM_MP_STATE_OPERATING
:
3759 rc
= kvm_s390_vcpu_start(vcpu
);
3761 case KVM_MP_STATE_LOAD
:
3762 if (!kvm_s390_pv_cpu_is_protected(vcpu
)) {
3766 rc
= kvm_s390_pv_set_cpu_state(vcpu
, PV_CPU_STATE_OPR_LOAD
);
3768 case KVM_MP_STATE_CHECK_STOP
:
3769 fallthrough
; /* CHECK_STOP and LOAD are not supported yet */
3778 static bool ibs_enabled(struct kvm_vcpu
*vcpu
)
3780 return kvm_s390_test_cpuflags(vcpu
, CPUSTAT_IBS
);
3783 static int kvm_s390_handle_requests(struct kvm_vcpu
*vcpu
)
3786 kvm_s390_vcpu_request_handled(vcpu
);
3787 if (!kvm_request_pending(vcpu
))
3790 * We use MMU_RELOAD just to re-arm the ipte notifier for the
3791 * guest prefix page. gmap_mprotect_notify will wait on the ptl lock.
3792 * This ensures that the ipte instruction for this request has
3793 * already finished. We might race against a second unmapper that
3794 * wants to set the blocking bit. Lets just retry the request loop.
3796 if (kvm_check_request(KVM_REQ_MMU_RELOAD
, vcpu
)) {
3798 rc
= gmap_mprotect_notify(vcpu
->arch
.gmap
,
3799 kvm_s390_get_prefix(vcpu
),
3800 PAGE_SIZE
* 2, PROT_WRITE
);
3802 kvm_make_request(KVM_REQ_MMU_RELOAD
, vcpu
);
3808 if (kvm_check_request(KVM_REQ_TLB_FLUSH
, vcpu
)) {
3809 vcpu
->arch
.sie_block
->ihcpu
= 0xffff;
3813 if (kvm_check_request(KVM_REQ_ENABLE_IBS
, vcpu
)) {
3814 if (!ibs_enabled(vcpu
)) {
3815 trace_kvm_s390_enable_disable_ibs(vcpu
->vcpu_id
, 1);
3816 kvm_s390_set_cpuflags(vcpu
, CPUSTAT_IBS
);
3821 if (kvm_check_request(KVM_REQ_DISABLE_IBS
, vcpu
)) {
3822 if (ibs_enabled(vcpu
)) {
3823 trace_kvm_s390_enable_disable_ibs(vcpu
->vcpu_id
, 0);
3824 kvm_s390_clear_cpuflags(vcpu
, CPUSTAT_IBS
);
3829 if (kvm_check_request(KVM_REQ_ICPT_OPEREXC
, vcpu
)) {
3830 vcpu
->arch
.sie_block
->ictl
|= ICTL_OPEREXC
;
3834 if (kvm_check_request(KVM_REQ_START_MIGRATION
, vcpu
)) {
3836 * Disable CMM virtualization; we will emulate the ESSA
3837 * instruction manually, in order to provide additional
3838 * functionalities needed for live migration.
3840 vcpu
->arch
.sie_block
->ecb2
&= ~ECB2_CMMA
;
3844 if (kvm_check_request(KVM_REQ_STOP_MIGRATION
, vcpu
)) {
3846 * Re-enable CMM virtualization if CMMA is available and
3847 * CMM has been used.
3849 if ((vcpu
->kvm
->arch
.use_cmma
) &&
3850 (vcpu
->kvm
->mm
->context
.uses_cmm
))
3851 vcpu
->arch
.sie_block
->ecb2
|= ECB2_CMMA
;
3855 /* nothing to do, just clear the request */
3856 kvm_clear_request(KVM_REQ_UNHALT
, vcpu
);
3857 /* we left the vsie handler, nothing to do, just clear the request */
3858 kvm_clear_request(KVM_REQ_VSIE_RESTART
, vcpu
);
3863 void kvm_s390_set_tod_clock(struct kvm
*kvm
,
3864 const struct kvm_s390_vm_tod_clock
*gtod
)
3866 struct kvm_vcpu
*vcpu
;
3867 struct kvm_s390_tod_clock_ext htod
;
3870 mutex_lock(&kvm
->lock
);
3873 get_tod_clock_ext((char *)&htod
);
3875 kvm
->arch
.epoch
= gtod
->tod
- htod
.tod
;
3877 if (test_kvm_facility(kvm
, 139)) {
3878 kvm
->arch
.epdx
= gtod
->epoch_idx
- htod
.epoch_idx
;
3879 if (kvm
->arch
.epoch
> gtod
->tod
)
3880 kvm
->arch
.epdx
-= 1;
3883 kvm_s390_vcpu_block_all(kvm
);
3884 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
3885 vcpu
->arch
.sie_block
->epoch
= kvm
->arch
.epoch
;
3886 vcpu
->arch
.sie_block
->epdx
= kvm
->arch
.epdx
;
3889 kvm_s390_vcpu_unblock_all(kvm
);
3891 mutex_unlock(&kvm
->lock
);
3895 * kvm_arch_fault_in_page - fault-in guest page if necessary
3896 * @vcpu: The corresponding virtual cpu
3897 * @gpa: Guest physical address
3898 * @writable: Whether the page should be writable or not
3900 * Make sure that a guest page has been faulted-in on the host.
3902 * Return: Zero on success, negative error code otherwise.
3904 long kvm_arch_fault_in_page(struct kvm_vcpu
*vcpu
, gpa_t gpa
, int writable
)
3906 return gmap_fault(vcpu
->arch
.gmap
, gpa
,
3907 writable
? FAULT_FLAG_WRITE
: 0);
3910 static void __kvm_inject_pfault_token(struct kvm_vcpu
*vcpu
, bool start_token
,
3911 unsigned long token
)
3913 struct kvm_s390_interrupt inti
;
3914 struct kvm_s390_irq irq
;
3917 irq
.u
.ext
.ext_params2
= token
;
3918 irq
.type
= KVM_S390_INT_PFAULT_INIT
;
3919 WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu
, &irq
));
3921 inti
.type
= KVM_S390_INT_PFAULT_DONE
;
3922 inti
.parm64
= token
;
3923 WARN_ON_ONCE(kvm_s390_inject_vm(vcpu
->kvm
, &inti
));
3927 void kvm_arch_async_page_not_present(struct kvm_vcpu
*vcpu
,
3928 struct kvm_async_pf
*work
)
3930 trace_kvm_s390_pfault_init(vcpu
, work
->arch
.pfault_token
);
3931 __kvm_inject_pfault_token(vcpu
, true, work
->arch
.pfault_token
);
3934 void kvm_arch_async_page_present(struct kvm_vcpu
*vcpu
,
3935 struct kvm_async_pf
*work
)
3937 trace_kvm_s390_pfault_done(vcpu
, work
->arch
.pfault_token
);
3938 __kvm_inject_pfault_token(vcpu
, false, work
->arch
.pfault_token
);
3941 void kvm_arch_async_page_ready(struct kvm_vcpu
*vcpu
,
3942 struct kvm_async_pf
*work
)
3944 /* s390 will always inject the page directly */
3947 bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu
*vcpu
)
3950 * s390 will always inject the page directly,
3951 * but we still want check_async_completion to cleanup
3956 static int kvm_arch_setup_async_pf(struct kvm_vcpu
*vcpu
)
3959 struct kvm_arch_async_pf arch
;
3962 if (vcpu
->arch
.pfault_token
== KVM_S390_PFAULT_TOKEN_INVALID
)
3964 if ((vcpu
->arch
.sie_block
->gpsw
.mask
& vcpu
->arch
.pfault_select
) !=
3965 vcpu
->arch
.pfault_compare
)
3967 if (psw_extint_disabled(vcpu
))
3969 if (kvm_s390_vcpu_has_irq(vcpu
, 0))
3971 if (!(vcpu
->arch
.sie_block
->gcr
[0] & CR0_SERVICE_SIGNAL_SUBMASK
))
3973 if (!vcpu
->arch
.gmap
->pfault_enabled
)
3976 hva
= gfn_to_hva(vcpu
->kvm
, gpa_to_gfn(current
->thread
.gmap_addr
));
3977 hva
+= current
->thread
.gmap_addr
& ~PAGE_MASK
;
3978 if (read_guest_real(vcpu
, vcpu
->arch
.pfault_token
, &arch
.pfault_token
, 8))
3981 rc
= kvm_setup_async_pf(vcpu
, current
->thread
.gmap_addr
, hva
, &arch
);
3985 static int vcpu_pre_run(struct kvm_vcpu
*vcpu
)
3990 * On s390 notifications for arriving pages will be delivered directly
3991 * to the guest but the house keeping for completed pfaults is
3992 * handled outside the worker.
3994 kvm_check_async_pf_completion(vcpu
);
3996 vcpu
->arch
.sie_block
->gg14
= vcpu
->run
->s
.regs
.gprs
[14];
3997 vcpu
->arch
.sie_block
->gg15
= vcpu
->run
->s
.regs
.gprs
[15];
4002 if (test_cpu_flag(CIF_MCCK_PENDING
))
4005 if (!kvm_is_ucontrol(vcpu
->kvm
)) {
4006 rc
= kvm_s390_deliver_pending_interrupts(vcpu
);
4011 rc
= kvm_s390_handle_requests(vcpu
);
4015 if (guestdbg_enabled(vcpu
)) {
4016 kvm_s390_backup_guest_per_regs(vcpu
);
4017 kvm_s390_patch_guest_per_regs(vcpu
);
4020 clear_bit(vcpu
->vcpu_id
, vcpu
->kvm
->arch
.gisa_int
.kicked_mask
);
4022 vcpu
->arch
.sie_block
->icptcode
= 0;
4023 cpuflags
= atomic_read(&vcpu
->arch
.sie_block
->cpuflags
);
4024 VCPU_EVENT(vcpu
, 6, "entering sie flags %x", cpuflags
);
4025 trace_kvm_s390_sie_enter(vcpu
, cpuflags
);
4030 static int vcpu_post_run_fault_in_sie(struct kvm_vcpu
*vcpu
)
4032 struct kvm_s390_pgm_info pgm_info
= {
4033 .code
= PGM_ADDRESSING
,
4038 VCPU_EVENT(vcpu
, 3, "%s", "fault in sie instruction");
4039 trace_kvm_s390_sie_fault(vcpu
);
4042 * We want to inject an addressing exception, which is defined as a
4043 * suppressing or terminating exception. However, since we came here
4044 * by a DAT access exception, the PSW still points to the faulting
4045 * instruction since DAT exceptions are nullifying. So we've got
4046 * to look up the current opcode to get the length of the instruction
4047 * to be able to forward the PSW.
4049 rc
= read_guest_instr(vcpu
, vcpu
->arch
.sie_block
->gpsw
.addr
, &opcode
, 1);
4050 ilen
= insn_length(opcode
);
4054 /* Instruction-Fetching Exceptions - we can't detect the ilen.
4055 * Forward by arbitrary ilc, injection will take care of
4056 * nullification if necessary.
4058 pgm_info
= vcpu
->arch
.pgm
;
4061 pgm_info
.flags
= ilen
| KVM_S390_PGM_FLAGS_ILC_VALID
;
4062 kvm_s390_forward_psw(vcpu
, ilen
);
4063 return kvm_s390_inject_prog_irq(vcpu
, &pgm_info
);
4066 static int vcpu_post_run(struct kvm_vcpu
*vcpu
, int exit_reason
)
4068 struct mcck_volatile_info
*mcck_info
;
4069 struct sie_page
*sie_page
;
4071 VCPU_EVENT(vcpu
, 6, "exit sie icptcode %d",
4072 vcpu
->arch
.sie_block
->icptcode
);
4073 trace_kvm_s390_sie_exit(vcpu
, vcpu
->arch
.sie_block
->icptcode
);
4075 if (guestdbg_enabled(vcpu
))
4076 kvm_s390_restore_guest_per_regs(vcpu
);
4078 vcpu
->run
->s
.regs
.gprs
[14] = vcpu
->arch
.sie_block
->gg14
;
4079 vcpu
->run
->s
.regs
.gprs
[15] = vcpu
->arch
.sie_block
->gg15
;
4081 if (exit_reason
== -EINTR
) {
4082 VCPU_EVENT(vcpu
, 3, "%s", "machine check");
4083 sie_page
= container_of(vcpu
->arch
.sie_block
,
4084 struct sie_page
, sie_block
);
4085 mcck_info
= &sie_page
->mcck_info
;
4086 kvm_s390_reinject_machine_check(vcpu
, mcck_info
);
4090 if (vcpu
->arch
.sie_block
->icptcode
> 0) {
4091 int rc
= kvm_handle_sie_intercept(vcpu
);
4093 if (rc
!= -EOPNOTSUPP
)
4095 vcpu
->run
->exit_reason
= KVM_EXIT_S390_SIEIC
;
4096 vcpu
->run
->s390_sieic
.icptcode
= vcpu
->arch
.sie_block
->icptcode
;
4097 vcpu
->run
->s390_sieic
.ipa
= vcpu
->arch
.sie_block
->ipa
;
4098 vcpu
->run
->s390_sieic
.ipb
= vcpu
->arch
.sie_block
->ipb
;
4100 } else if (exit_reason
!= -EFAULT
) {
4101 vcpu
->stat
.exit_null
++;
4103 } else if (kvm_is_ucontrol(vcpu
->kvm
)) {
4104 vcpu
->run
->exit_reason
= KVM_EXIT_S390_UCONTROL
;
4105 vcpu
->run
->s390_ucontrol
.trans_exc_code
=
4106 current
->thread
.gmap_addr
;
4107 vcpu
->run
->s390_ucontrol
.pgm_code
= 0x10;
4109 } else if (current
->thread
.gmap_pfault
) {
4110 trace_kvm_s390_major_guest_pfault(vcpu
);
4111 current
->thread
.gmap_pfault
= 0;
4112 if (kvm_arch_setup_async_pf(vcpu
))
4114 return kvm_arch_fault_in_page(vcpu
, current
->thread
.gmap_addr
, 1);
4116 return vcpu_post_run_fault_in_sie(vcpu
);
4119 #define PSW_INT_MASK (PSW_MASK_EXT | PSW_MASK_IO | PSW_MASK_MCHECK)
4120 static int __vcpu_run(struct kvm_vcpu
*vcpu
)
4122 int rc
, exit_reason
;
4123 struct sie_page
*sie_page
= (struct sie_page
*)vcpu
->arch
.sie_block
;
4126 * We try to hold kvm->srcu during most of vcpu_run (except when run-
4127 * ning the guest), so that memslots (and other stuff) are protected
4129 vcpu
->srcu_idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
4132 rc
= vcpu_pre_run(vcpu
);
4136 srcu_read_unlock(&vcpu
->kvm
->srcu
, vcpu
->srcu_idx
);
4138 * As PF_VCPU will be used in fault handler, between
4139 * guest_enter and guest_exit should be no uaccess.
4141 local_irq_disable();
4142 guest_enter_irqoff();
4143 __disable_cpu_timer_accounting(vcpu
);
4145 if (kvm_s390_pv_cpu_is_protected(vcpu
)) {
4146 memcpy(sie_page
->pv_grregs
,
4147 vcpu
->run
->s
.regs
.gprs
,
4148 sizeof(sie_page
->pv_grregs
));
4150 exit_reason
= sie64a(vcpu
->arch
.sie_block
,
4151 vcpu
->run
->s
.regs
.gprs
);
4152 if (kvm_s390_pv_cpu_is_protected(vcpu
)) {
4153 memcpy(vcpu
->run
->s
.regs
.gprs
,
4154 sie_page
->pv_grregs
,
4155 sizeof(sie_page
->pv_grregs
));
4157 * We're not allowed to inject interrupts on intercepts
4158 * that leave the guest state in an "in-between" state
4159 * where the next SIE entry will do a continuation.
4160 * Fence interrupts in our "internal" PSW.
4162 if (vcpu
->arch
.sie_block
->icptcode
== ICPT_PV_INSTR
||
4163 vcpu
->arch
.sie_block
->icptcode
== ICPT_PV_PREF
) {
4164 vcpu
->arch
.sie_block
->gpsw
.mask
&= ~PSW_INT_MASK
;
4167 local_irq_disable();
4168 __enable_cpu_timer_accounting(vcpu
);
4169 guest_exit_irqoff();
4171 vcpu
->srcu_idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
4173 rc
= vcpu_post_run(vcpu
, exit_reason
);
4174 } while (!signal_pending(current
) && !guestdbg_exit_pending(vcpu
) && !rc
);
4176 srcu_read_unlock(&vcpu
->kvm
->srcu
, vcpu
->srcu_idx
);
4180 static void sync_regs_fmt2(struct kvm_vcpu
*vcpu
, struct kvm_run
*kvm_run
)
4182 struct runtime_instr_cb
*riccb
;
4185 riccb
= (struct runtime_instr_cb
*) &kvm_run
->s
.regs
.riccb
;
4186 gscb
= (struct gs_cb
*) &kvm_run
->s
.regs
.gscb
;
4187 vcpu
->arch
.sie_block
->gpsw
.mask
= kvm_run
->psw_mask
;
4188 vcpu
->arch
.sie_block
->gpsw
.addr
= kvm_run
->psw_addr
;
4189 if (kvm_run
->kvm_dirty_regs
& KVM_SYNC_ARCH0
) {
4190 vcpu
->arch
.sie_block
->todpr
= kvm_run
->s
.regs
.todpr
;
4191 vcpu
->arch
.sie_block
->pp
= kvm_run
->s
.regs
.pp
;
4192 vcpu
->arch
.sie_block
->gbea
= kvm_run
->s
.regs
.gbea
;
4194 if (kvm_run
->kvm_dirty_regs
& KVM_SYNC_PFAULT
) {
4195 vcpu
->arch
.pfault_token
= kvm_run
->s
.regs
.pft
;
4196 vcpu
->arch
.pfault_select
= kvm_run
->s
.regs
.pfs
;
4197 vcpu
->arch
.pfault_compare
= kvm_run
->s
.regs
.pfc
;
4198 if (vcpu
->arch
.pfault_token
== KVM_S390_PFAULT_TOKEN_INVALID
)
4199 kvm_clear_async_pf_completion_queue(vcpu
);
4202 * If userspace sets the riccb (e.g. after migration) to a valid state,
4203 * we should enable RI here instead of doing the lazy enablement.
4205 if ((kvm_run
->kvm_dirty_regs
& KVM_SYNC_RICCB
) &&
4206 test_kvm_facility(vcpu
->kvm
, 64) &&
4208 !(vcpu
->arch
.sie_block
->ecb3
& ECB3_RI
)) {
4209 VCPU_EVENT(vcpu
, 3, "%s", "ENABLE: RI (sync_regs)");
4210 vcpu
->arch
.sie_block
->ecb3
|= ECB3_RI
;
4213 * If userspace sets the gscb (e.g. after migration) to non-zero,
4214 * we should enable GS here instead of doing the lazy enablement.
4216 if ((kvm_run
->kvm_dirty_regs
& KVM_SYNC_GSCB
) &&
4217 test_kvm_facility(vcpu
->kvm
, 133) &&
4219 !vcpu
->arch
.gs_enabled
) {
4220 VCPU_EVENT(vcpu
, 3, "%s", "ENABLE: GS (sync_regs)");
4221 vcpu
->arch
.sie_block
->ecb
|= ECB_GS
;
4222 vcpu
->arch
.sie_block
->ecd
|= ECD_HOSTREGMGMT
;
4223 vcpu
->arch
.gs_enabled
= 1;
4225 if ((kvm_run
->kvm_dirty_regs
& KVM_SYNC_BPBC
) &&
4226 test_kvm_facility(vcpu
->kvm
, 82)) {
4227 vcpu
->arch
.sie_block
->fpf
&= ~FPF_BPBC
;
4228 vcpu
->arch
.sie_block
->fpf
|= kvm_run
->s
.regs
.bpbc
? FPF_BPBC
: 0;
4230 if (MACHINE_HAS_GS
) {
4232 __ctl_set_bit(2, 4);
4233 if (current
->thread
.gs_cb
) {
4234 vcpu
->arch
.host_gscb
= current
->thread
.gs_cb
;
4235 save_gs_cb(vcpu
->arch
.host_gscb
);
4237 if (vcpu
->arch
.gs_enabled
) {
4238 current
->thread
.gs_cb
= (struct gs_cb
*)
4239 &vcpu
->run
->s
.regs
.gscb
;
4240 restore_gs_cb(current
->thread
.gs_cb
);
4244 /* SIE will load etoken directly from SDNX and therefore kvm_run */
4247 static void sync_regs(struct kvm_vcpu
*vcpu
, struct kvm_run
*kvm_run
)
4249 if (kvm_run
->kvm_dirty_regs
& KVM_SYNC_PREFIX
)
4250 kvm_s390_set_prefix(vcpu
, kvm_run
->s
.regs
.prefix
);
4251 if (kvm_run
->kvm_dirty_regs
& KVM_SYNC_CRS
) {
4252 memcpy(&vcpu
->arch
.sie_block
->gcr
, &kvm_run
->s
.regs
.crs
, 128);
4253 /* some control register changes require a tlb flush */
4254 kvm_make_request(KVM_REQ_TLB_FLUSH
, vcpu
);
4256 if (kvm_run
->kvm_dirty_regs
& KVM_SYNC_ARCH0
) {
4257 kvm_s390_set_cpu_timer(vcpu
, kvm_run
->s
.regs
.cputm
);
4258 vcpu
->arch
.sie_block
->ckc
= kvm_run
->s
.regs
.ckc
;
4260 save_access_regs(vcpu
->arch
.host_acrs
);
4261 restore_access_regs(vcpu
->run
->s
.regs
.acrs
);
4262 /* save host (userspace) fprs/vrs */
4264 vcpu
->arch
.host_fpregs
.fpc
= current
->thread
.fpu
.fpc
;
4265 vcpu
->arch
.host_fpregs
.regs
= current
->thread
.fpu
.regs
;
4267 current
->thread
.fpu
.regs
= vcpu
->run
->s
.regs
.vrs
;
4269 current
->thread
.fpu
.regs
= vcpu
->run
->s
.regs
.fprs
;
4270 current
->thread
.fpu
.fpc
= vcpu
->run
->s
.regs
.fpc
;
4271 if (test_fp_ctl(current
->thread
.fpu
.fpc
))
4272 /* User space provided an invalid FPC, let's clear it */
4273 current
->thread
.fpu
.fpc
= 0;
4275 /* Sync fmt2 only data */
4276 if (likely(!kvm_s390_pv_cpu_is_protected(vcpu
))) {
4277 sync_regs_fmt2(vcpu
, kvm_run
);
4280 * In several places we have to modify our internal view to
4281 * not do things that are disallowed by the ultravisor. For
4282 * example we must not inject interrupts after specific exits
4283 * (e.g. 112 prefix page not secure). We do this by turning
4284 * off the machine check, external and I/O interrupt bits
4285 * of our PSW copy. To avoid getting validity intercepts, we
4286 * do only accept the condition code from userspace.
4288 vcpu
->arch
.sie_block
->gpsw
.mask
&= ~PSW_MASK_CC
;
4289 vcpu
->arch
.sie_block
->gpsw
.mask
|= kvm_run
->psw_mask
&
4293 kvm_run
->kvm_dirty_regs
= 0;
4296 static void store_regs_fmt2(struct kvm_vcpu
*vcpu
, struct kvm_run
*kvm_run
)
4298 kvm_run
->s
.regs
.todpr
= vcpu
->arch
.sie_block
->todpr
;
4299 kvm_run
->s
.regs
.pp
= vcpu
->arch
.sie_block
->pp
;
4300 kvm_run
->s
.regs
.gbea
= vcpu
->arch
.sie_block
->gbea
;
4301 kvm_run
->s
.regs
.bpbc
= (vcpu
->arch
.sie_block
->fpf
& FPF_BPBC
) == FPF_BPBC
;
4302 if (MACHINE_HAS_GS
) {
4303 __ctl_set_bit(2, 4);
4304 if (vcpu
->arch
.gs_enabled
)
4305 save_gs_cb(current
->thread
.gs_cb
);
4307 current
->thread
.gs_cb
= vcpu
->arch
.host_gscb
;
4308 restore_gs_cb(vcpu
->arch
.host_gscb
);
4310 if (!vcpu
->arch
.host_gscb
)
4311 __ctl_clear_bit(2, 4);
4312 vcpu
->arch
.host_gscb
= NULL
;
4314 /* SIE will save etoken directly into SDNX and therefore kvm_run */
4317 static void store_regs(struct kvm_vcpu
*vcpu
, struct kvm_run
*kvm_run
)
4319 kvm_run
->psw_mask
= vcpu
->arch
.sie_block
->gpsw
.mask
;
4320 kvm_run
->psw_addr
= vcpu
->arch
.sie_block
->gpsw
.addr
;
4321 kvm_run
->s
.regs
.prefix
= kvm_s390_get_prefix(vcpu
);
4322 memcpy(&kvm_run
->s
.regs
.crs
, &vcpu
->arch
.sie_block
->gcr
, 128);
4323 kvm_run
->s
.regs
.cputm
= kvm_s390_get_cpu_timer(vcpu
);
4324 kvm_run
->s
.regs
.ckc
= vcpu
->arch
.sie_block
->ckc
;
4325 kvm_run
->s
.regs
.pft
= vcpu
->arch
.pfault_token
;
4326 kvm_run
->s
.regs
.pfs
= vcpu
->arch
.pfault_select
;
4327 kvm_run
->s
.regs
.pfc
= vcpu
->arch
.pfault_compare
;
4328 save_access_regs(vcpu
->run
->s
.regs
.acrs
);
4329 restore_access_regs(vcpu
->arch
.host_acrs
);
4330 /* Save guest register state */
4332 vcpu
->run
->s
.regs
.fpc
= current
->thread
.fpu
.fpc
;
4333 /* Restore will be done lazily at return */
4334 current
->thread
.fpu
.fpc
= vcpu
->arch
.host_fpregs
.fpc
;
4335 current
->thread
.fpu
.regs
= vcpu
->arch
.host_fpregs
.regs
;
4336 if (likely(!kvm_s390_pv_cpu_is_protected(vcpu
)))
4337 store_regs_fmt2(vcpu
, kvm_run
);
4340 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu
*vcpu
, struct kvm_run
*kvm_run
)
4344 if (kvm_run
->immediate_exit
)
4347 if (kvm_run
->kvm_valid_regs
& ~KVM_SYNC_S390_VALID_FIELDS
||
4348 kvm_run
->kvm_dirty_regs
& ~KVM_SYNC_S390_VALID_FIELDS
)
4353 if (guestdbg_exit_pending(vcpu
)) {
4354 kvm_s390_prepare_debug_exit(vcpu
);
4359 kvm_sigset_activate(vcpu
);
4362 * no need to check the return value of vcpu_start as it can only have
4363 * an error for protvirt, but protvirt means user cpu state
4365 if (!kvm_s390_user_cpu_state_ctrl(vcpu
->kvm
)) {
4366 kvm_s390_vcpu_start(vcpu
);
4367 } else if (is_vcpu_stopped(vcpu
)) {
4368 pr_err_ratelimited("can't run stopped vcpu %d\n",
4374 sync_regs(vcpu
, kvm_run
);
4375 enable_cpu_timer_accounting(vcpu
);
4378 rc
= __vcpu_run(vcpu
);
4380 if (signal_pending(current
) && !rc
) {
4381 kvm_run
->exit_reason
= KVM_EXIT_INTR
;
4385 if (guestdbg_exit_pending(vcpu
) && !rc
) {
4386 kvm_s390_prepare_debug_exit(vcpu
);
4390 if (rc
== -EREMOTE
) {
4391 /* userspace support is needed, kvm_run has been prepared */
4395 disable_cpu_timer_accounting(vcpu
);
4396 store_regs(vcpu
, kvm_run
);
4398 kvm_sigset_deactivate(vcpu
);
4400 vcpu
->stat
.exit_userspace
++;
4407 * store status at address
4408 * we use have two special cases:
4409 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
4410 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
4412 int kvm_s390_store_status_unloaded(struct kvm_vcpu
*vcpu
, unsigned long gpa
)
4414 unsigned char archmode
= 1;
4415 freg_t fprs
[NUM_FPRS
];
4420 px
= kvm_s390_get_prefix(vcpu
);
4421 if (gpa
== KVM_S390_STORE_STATUS_NOADDR
) {
4422 if (write_guest_abs(vcpu
, 163, &archmode
, 1))
4425 } else if (gpa
== KVM_S390_STORE_STATUS_PREFIXED
) {
4426 if (write_guest_real(vcpu
, 163, &archmode
, 1))
4430 gpa
-= __LC_FPREGS_SAVE_AREA
;
4432 /* manually convert vector registers if necessary */
4433 if (MACHINE_HAS_VX
) {
4434 convert_vx_to_fp(fprs
, (__vector128
*) vcpu
->run
->s
.regs
.vrs
);
4435 rc
= write_guest_abs(vcpu
, gpa
+ __LC_FPREGS_SAVE_AREA
,
4438 rc
= write_guest_abs(vcpu
, gpa
+ __LC_FPREGS_SAVE_AREA
,
4439 vcpu
->run
->s
.regs
.fprs
, 128);
4441 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_GPREGS_SAVE_AREA
,
4442 vcpu
->run
->s
.regs
.gprs
, 128);
4443 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_PSW_SAVE_AREA
,
4444 &vcpu
->arch
.sie_block
->gpsw
, 16);
4445 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_PREFIX_SAVE_AREA
,
4447 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_FP_CREG_SAVE_AREA
,
4448 &vcpu
->run
->s
.regs
.fpc
, 4);
4449 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_TOD_PROGREG_SAVE_AREA
,
4450 &vcpu
->arch
.sie_block
->todpr
, 4);
4451 cputm
= kvm_s390_get_cpu_timer(vcpu
);
4452 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_CPU_TIMER_SAVE_AREA
,
4454 clkcomp
= vcpu
->arch
.sie_block
->ckc
>> 8;
4455 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_CLOCK_COMP_SAVE_AREA
,
4457 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_AREGS_SAVE_AREA
,
4458 &vcpu
->run
->s
.regs
.acrs
, 64);
4459 rc
|= write_guest_abs(vcpu
, gpa
+ __LC_CREGS_SAVE_AREA
,
4460 &vcpu
->arch
.sie_block
->gcr
, 128);
4461 return rc
? -EFAULT
: 0;
4464 int kvm_s390_vcpu_store_status(struct kvm_vcpu
*vcpu
, unsigned long addr
)
4467 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
4468 * switch in the run ioctl. Let's update our copies before we save
4469 * it into the save area
4472 vcpu
->run
->s
.regs
.fpc
= current
->thread
.fpu
.fpc
;
4473 save_access_regs(vcpu
->run
->s
.regs
.acrs
);
4475 return kvm_s390_store_status_unloaded(vcpu
, addr
);
4478 static void __disable_ibs_on_vcpu(struct kvm_vcpu
*vcpu
)
4480 kvm_check_request(KVM_REQ_ENABLE_IBS
, vcpu
);
4481 kvm_s390_sync_request(KVM_REQ_DISABLE_IBS
, vcpu
);
4484 static void __disable_ibs_on_all_vcpus(struct kvm
*kvm
)
4487 struct kvm_vcpu
*vcpu
;
4489 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
4490 __disable_ibs_on_vcpu(vcpu
);
4494 static void __enable_ibs_on_vcpu(struct kvm_vcpu
*vcpu
)
4498 kvm_check_request(KVM_REQ_DISABLE_IBS
, vcpu
);
4499 kvm_s390_sync_request(KVM_REQ_ENABLE_IBS
, vcpu
);
4502 int kvm_s390_vcpu_start(struct kvm_vcpu
*vcpu
)
4504 int i
, online_vcpus
, r
= 0, started_vcpus
= 0;
4506 if (!is_vcpu_stopped(vcpu
))
4509 trace_kvm_s390_vcpu_start_stop(vcpu
->vcpu_id
, 1);
4510 /* Only one cpu at a time may enter/leave the STOPPED state. */
4511 spin_lock(&vcpu
->kvm
->arch
.start_stop_lock
);
4512 online_vcpus
= atomic_read(&vcpu
->kvm
->online_vcpus
);
4514 /* Let's tell the UV that we want to change into the operating state */
4515 if (kvm_s390_pv_cpu_is_protected(vcpu
)) {
4516 r
= kvm_s390_pv_set_cpu_state(vcpu
, PV_CPU_STATE_OPR
);
4518 spin_unlock(&vcpu
->kvm
->arch
.start_stop_lock
);
4523 for (i
= 0; i
< online_vcpus
; i
++) {
4524 if (!is_vcpu_stopped(vcpu
->kvm
->vcpus
[i
]))
4528 if (started_vcpus
== 0) {
4529 /* we're the only active VCPU -> speed it up */
4530 __enable_ibs_on_vcpu(vcpu
);
4531 } else if (started_vcpus
== 1) {
4533 * As we are starting a second VCPU, we have to disable
4534 * the IBS facility on all VCPUs to remove potentially
4535 * oustanding ENABLE requests.
4537 __disable_ibs_on_all_vcpus(vcpu
->kvm
);
4540 kvm_s390_clear_cpuflags(vcpu
, CPUSTAT_STOPPED
);
4542 * The real PSW might have changed due to a RESTART interpreted by the
4543 * ultravisor. We block all interrupts and let the next sie exit
4546 if (kvm_s390_pv_cpu_is_protected(vcpu
))
4547 vcpu
->arch
.sie_block
->gpsw
.mask
&= ~PSW_INT_MASK
;
4549 * Another VCPU might have used IBS while we were offline.
4550 * Let's play safe and flush the VCPU at startup.
4552 kvm_make_request(KVM_REQ_TLB_FLUSH
, vcpu
);
4553 spin_unlock(&vcpu
->kvm
->arch
.start_stop_lock
);
4557 int kvm_s390_vcpu_stop(struct kvm_vcpu
*vcpu
)
4559 int i
, online_vcpus
, r
= 0, started_vcpus
= 0;
4560 struct kvm_vcpu
*started_vcpu
= NULL
;
4562 if (is_vcpu_stopped(vcpu
))
4565 trace_kvm_s390_vcpu_start_stop(vcpu
->vcpu_id
, 0);
4566 /* Only one cpu at a time may enter/leave the STOPPED state. */
4567 spin_lock(&vcpu
->kvm
->arch
.start_stop_lock
);
4568 online_vcpus
= atomic_read(&vcpu
->kvm
->online_vcpus
);
4570 /* Let's tell the UV that we want to change into the stopped state */
4571 if (kvm_s390_pv_cpu_is_protected(vcpu
)) {
4572 r
= kvm_s390_pv_set_cpu_state(vcpu
, PV_CPU_STATE_STP
);
4574 spin_unlock(&vcpu
->kvm
->arch
.start_stop_lock
);
4579 /* SIGP STOP and SIGP STOP AND STORE STATUS has been fully processed */
4580 kvm_s390_clear_stop_irq(vcpu
);
4582 kvm_s390_set_cpuflags(vcpu
, CPUSTAT_STOPPED
);
4583 __disable_ibs_on_vcpu(vcpu
);
4585 for (i
= 0; i
< online_vcpus
; i
++) {
4586 if (!is_vcpu_stopped(vcpu
->kvm
->vcpus
[i
])) {
4588 started_vcpu
= vcpu
->kvm
->vcpus
[i
];
4592 if (started_vcpus
== 1) {
4594 * As we only have one VCPU left, we want to enable the
4595 * IBS facility for that VCPU to speed it up.
4597 __enable_ibs_on_vcpu(started_vcpu
);
4600 spin_unlock(&vcpu
->kvm
->arch
.start_stop_lock
);
4604 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu
*vcpu
,
4605 struct kvm_enable_cap
*cap
)
4613 case KVM_CAP_S390_CSS_SUPPORT
:
4614 if (!vcpu
->kvm
->arch
.css_support
) {
4615 vcpu
->kvm
->arch
.css_support
= 1;
4616 VM_EVENT(vcpu
->kvm
, 3, "%s", "ENABLE: CSS support");
4617 trace_kvm_s390_enable_css(vcpu
->kvm
);
4628 static long kvm_s390_guest_sida_op(struct kvm_vcpu
*vcpu
,
4629 struct kvm_s390_mem_op
*mop
)
4631 void __user
*uaddr
= (void __user
*)mop
->buf
;
4634 if (mop
->flags
|| !mop
->size
)
4636 if (mop
->size
+ mop
->sida_offset
< mop
->size
)
4638 if (mop
->size
+ mop
->sida_offset
> sida_size(vcpu
->arch
.sie_block
))
4642 case KVM_S390_MEMOP_SIDA_READ
:
4643 if (copy_to_user(uaddr
, (void *)(sida_origin(vcpu
->arch
.sie_block
) +
4644 mop
->sida_offset
), mop
->size
))
4648 case KVM_S390_MEMOP_SIDA_WRITE
:
4649 if (copy_from_user((void *)(sida_origin(vcpu
->arch
.sie_block
) +
4650 mop
->sida_offset
), uaddr
, mop
->size
))
4656 static long kvm_s390_guest_mem_op(struct kvm_vcpu
*vcpu
,
4657 struct kvm_s390_mem_op
*mop
)
4659 void __user
*uaddr
= (void __user
*)mop
->buf
;
4660 void *tmpbuf
= NULL
;
4662 const u64 supported_flags
= KVM_S390_MEMOP_F_INJECT_EXCEPTION
4663 | KVM_S390_MEMOP_F_CHECK_ONLY
;
4665 if (mop
->flags
& ~supported_flags
|| mop
->ar
>= NUM_ACRS
|| !mop
->size
)
4668 if (mop
->size
> MEM_OP_MAX_SIZE
)
4671 if (kvm_s390_pv_cpu_is_protected(vcpu
))
4674 if (!(mop
->flags
& KVM_S390_MEMOP_F_CHECK_ONLY
)) {
4675 tmpbuf
= vmalloc(mop
->size
);
4681 case KVM_S390_MEMOP_LOGICAL_READ
:
4682 if (mop
->flags
& KVM_S390_MEMOP_F_CHECK_ONLY
) {
4683 r
= check_gva_range(vcpu
, mop
->gaddr
, mop
->ar
,
4684 mop
->size
, GACC_FETCH
);
4687 r
= read_guest(vcpu
, mop
->gaddr
, mop
->ar
, tmpbuf
, mop
->size
);
4689 if (copy_to_user(uaddr
, tmpbuf
, mop
->size
))
4693 case KVM_S390_MEMOP_LOGICAL_WRITE
:
4694 if (mop
->flags
& KVM_S390_MEMOP_F_CHECK_ONLY
) {
4695 r
= check_gva_range(vcpu
, mop
->gaddr
, mop
->ar
,
4696 mop
->size
, GACC_STORE
);
4699 if (copy_from_user(tmpbuf
, uaddr
, mop
->size
)) {
4703 r
= write_guest(vcpu
, mop
->gaddr
, mop
->ar
, tmpbuf
, mop
->size
);
4707 if (r
> 0 && (mop
->flags
& KVM_S390_MEMOP_F_INJECT_EXCEPTION
) != 0)
4708 kvm_s390_inject_prog_irq(vcpu
, &vcpu
->arch
.pgm
);
4714 static long kvm_s390_guest_memsida_op(struct kvm_vcpu
*vcpu
,
4715 struct kvm_s390_mem_op
*mop
)
4719 srcu_idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
4722 case KVM_S390_MEMOP_LOGICAL_READ
:
4723 case KVM_S390_MEMOP_LOGICAL_WRITE
:
4724 r
= kvm_s390_guest_mem_op(vcpu
, mop
);
4726 case KVM_S390_MEMOP_SIDA_READ
:
4727 case KVM_S390_MEMOP_SIDA_WRITE
:
4728 /* we are locked against sida going away by the vcpu->mutex */
4729 r
= kvm_s390_guest_sida_op(vcpu
, mop
);
4735 srcu_read_unlock(&vcpu
->kvm
->srcu
, srcu_idx
);
4739 long kvm_arch_vcpu_async_ioctl(struct file
*filp
,
4740 unsigned int ioctl
, unsigned long arg
)
4742 struct kvm_vcpu
*vcpu
= filp
->private_data
;
4743 void __user
*argp
= (void __user
*)arg
;
4746 case KVM_S390_IRQ
: {
4747 struct kvm_s390_irq s390irq
;
4749 if (copy_from_user(&s390irq
, argp
, sizeof(s390irq
)))
4751 return kvm_s390_inject_vcpu(vcpu
, &s390irq
);
4753 case KVM_S390_INTERRUPT
: {
4754 struct kvm_s390_interrupt s390int
;
4755 struct kvm_s390_irq s390irq
= {};
4757 if (copy_from_user(&s390int
, argp
, sizeof(s390int
)))
4759 if (s390int_to_s390irq(&s390int
, &s390irq
))
4761 return kvm_s390_inject_vcpu(vcpu
, &s390irq
);
4764 return -ENOIOCTLCMD
;
4767 long kvm_arch_vcpu_ioctl(struct file
*filp
,
4768 unsigned int ioctl
, unsigned long arg
)
4770 struct kvm_vcpu
*vcpu
= filp
->private_data
;
4771 void __user
*argp
= (void __user
*)arg
;
4779 case KVM_S390_STORE_STATUS
:
4780 idx
= srcu_read_lock(&vcpu
->kvm
->srcu
);
4781 r
= kvm_s390_store_status_unloaded(vcpu
, arg
);
4782 srcu_read_unlock(&vcpu
->kvm
->srcu
, idx
);
4784 case KVM_S390_SET_INITIAL_PSW
: {
4788 if (copy_from_user(&psw
, argp
, sizeof(psw
)))
4790 r
= kvm_arch_vcpu_ioctl_set_initial_psw(vcpu
, psw
);
4793 case KVM_S390_CLEAR_RESET
:
4795 kvm_arch_vcpu_ioctl_clear_reset(vcpu
);
4796 if (kvm_s390_pv_cpu_is_protected(vcpu
)) {
4797 r
= uv_cmd_nodata(kvm_s390_pv_cpu_get_handle(vcpu
),
4798 UVC_CMD_CPU_RESET_CLEAR
, &rc
, &rrc
);
4799 VCPU_EVENT(vcpu
, 3, "PROTVIRT RESET CLEAR VCPU: rc %x rrc %x",
4803 case KVM_S390_INITIAL_RESET
:
4805 kvm_arch_vcpu_ioctl_initial_reset(vcpu
);
4806 if (kvm_s390_pv_cpu_is_protected(vcpu
)) {
4807 r
= uv_cmd_nodata(kvm_s390_pv_cpu_get_handle(vcpu
),
4808 UVC_CMD_CPU_RESET_INITIAL
,
4810 VCPU_EVENT(vcpu
, 3, "PROTVIRT RESET INITIAL VCPU: rc %x rrc %x",
4814 case KVM_S390_NORMAL_RESET
:
4816 kvm_arch_vcpu_ioctl_normal_reset(vcpu
);
4817 if (kvm_s390_pv_cpu_is_protected(vcpu
)) {
4818 r
= uv_cmd_nodata(kvm_s390_pv_cpu_get_handle(vcpu
),
4819 UVC_CMD_CPU_RESET
, &rc
, &rrc
);
4820 VCPU_EVENT(vcpu
, 3, "PROTVIRT RESET NORMAL VCPU: rc %x rrc %x",
4824 case KVM_SET_ONE_REG
:
4825 case KVM_GET_ONE_REG
: {
4826 struct kvm_one_reg reg
;
4828 if (kvm_s390_pv_cpu_is_protected(vcpu
))
4831 if (copy_from_user(®
, argp
, sizeof(reg
)))
4833 if (ioctl
== KVM_SET_ONE_REG
)
4834 r
= kvm_arch_vcpu_ioctl_set_one_reg(vcpu
, ®
);
4836 r
= kvm_arch_vcpu_ioctl_get_one_reg(vcpu
, ®
);
4839 #ifdef CONFIG_KVM_S390_UCONTROL
4840 case KVM_S390_UCAS_MAP
: {
4841 struct kvm_s390_ucas_mapping ucasmap
;
4843 if (copy_from_user(&ucasmap
, argp
, sizeof(ucasmap
))) {
4848 if (!kvm_is_ucontrol(vcpu
->kvm
)) {
4853 r
= gmap_map_segment(vcpu
->arch
.gmap
, ucasmap
.user_addr
,
4854 ucasmap
.vcpu_addr
, ucasmap
.length
);
4857 case KVM_S390_UCAS_UNMAP
: {
4858 struct kvm_s390_ucas_mapping ucasmap
;
4860 if (copy_from_user(&ucasmap
, argp
, sizeof(ucasmap
))) {
4865 if (!kvm_is_ucontrol(vcpu
->kvm
)) {
4870 r
= gmap_unmap_segment(vcpu
->arch
.gmap
, ucasmap
.vcpu_addr
,
4875 case KVM_S390_VCPU_FAULT
: {
4876 r
= gmap_fault(vcpu
->arch
.gmap
, arg
, 0);
4879 case KVM_ENABLE_CAP
:
4881 struct kvm_enable_cap cap
;
4883 if (copy_from_user(&cap
, argp
, sizeof(cap
)))
4885 r
= kvm_vcpu_ioctl_enable_cap(vcpu
, &cap
);
4888 case KVM_S390_MEM_OP
: {
4889 struct kvm_s390_mem_op mem_op
;
4891 if (copy_from_user(&mem_op
, argp
, sizeof(mem_op
)) == 0)
4892 r
= kvm_s390_guest_memsida_op(vcpu
, &mem_op
);
4897 case KVM_S390_SET_IRQ_STATE
: {
4898 struct kvm_s390_irq_state irq_state
;
4901 if (copy_from_user(&irq_state
, argp
, sizeof(irq_state
)))
4903 if (irq_state
.len
> VCPU_IRQS_MAX_BUF
||
4904 irq_state
.len
== 0 ||
4905 irq_state
.len
% sizeof(struct kvm_s390_irq
) > 0) {
4909 /* do not use irq_state.flags, it will break old QEMUs */
4910 r
= kvm_s390_set_irq_state(vcpu
,
4911 (void __user
*) irq_state
.buf
,
4915 case KVM_S390_GET_IRQ_STATE
: {
4916 struct kvm_s390_irq_state irq_state
;
4919 if (copy_from_user(&irq_state
, argp
, sizeof(irq_state
)))
4921 if (irq_state
.len
== 0) {
4925 /* do not use irq_state.flags, it will break old QEMUs */
4926 r
= kvm_s390_get_irq_state(vcpu
,
4927 (__u8 __user
*) irq_state
.buf
,
4939 vm_fault_t
kvm_arch_vcpu_fault(struct kvm_vcpu
*vcpu
, struct vm_fault
*vmf
)
4941 #ifdef CONFIG_KVM_S390_UCONTROL
4942 if ((vmf
->pgoff
== KVM_S390_SIE_PAGE_OFFSET
)
4943 && (kvm_is_ucontrol(vcpu
->kvm
))) {
4944 vmf
->page
= virt_to_page(vcpu
->arch
.sie_block
);
4945 get_page(vmf
->page
);
4949 return VM_FAULT_SIGBUS
;
4952 /* Section: memory related */
4953 int kvm_arch_prepare_memory_region(struct kvm
*kvm
,
4954 struct kvm_memory_slot
*memslot
,
4955 const struct kvm_userspace_memory_region
*mem
,
4956 enum kvm_mr_change change
)
4958 /* A few sanity checks. We can have memory slots which have to be
4959 located/ended at a segment boundary (1MB). The memory in userland is
4960 ok to be fragmented into various different vmas. It is okay to mmap()
4961 and munmap() stuff in this slot after doing this call at any time */
4963 if (mem
->userspace_addr
& 0xffffful
)
4966 if (mem
->memory_size
& 0xffffful
)
4969 if (mem
->guest_phys_addr
+ mem
->memory_size
> kvm
->arch
.mem_limit
)
4972 /* When we are protected, we should not change the memory slots */
4973 if (kvm_s390_pv_get_handle(kvm
))
4978 void kvm_arch_commit_memory_region(struct kvm
*kvm
,
4979 const struct kvm_userspace_memory_region
*mem
,
4980 struct kvm_memory_slot
*old
,
4981 const struct kvm_memory_slot
*new,
4982 enum kvm_mr_change change
)
4988 rc
= gmap_unmap_segment(kvm
->arch
.gmap
, old
->base_gfn
* PAGE_SIZE
,
4989 old
->npages
* PAGE_SIZE
);
4992 rc
= gmap_unmap_segment(kvm
->arch
.gmap
, old
->base_gfn
* PAGE_SIZE
,
4993 old
->npages
* PAGE_SIZE
);
4998 rc
= gmap_map_segment(kvm
->arch
.gmap
, mem
->userspace_addr
,
4999 mem
->guest_phys_addr
, mem
->memory_size
);
5001 case KVM_MR_FLAGS_ONLY
:
5004 WARN(1, "Unknown KVM MR CHANGE: %d\n", change
);
5007 pr_warn("failed to commit memory region\n");
5011 static inline unsigned long nonhyp_mask(int i
)
5013 unsigned int nonhyp_fai
= (sclp
.hmfai
<< i
* 2) >> 30;
5015 return 0x0000ffffffffffffUL
>> (nonhyp_fai
<< 4);
5018 void kvm_arch_vcpu_block_finish(struct kvm_vcpu
*vcpu
)
5020 vcpu
->valid_wakeup
= false;
5023 static int __init
kvm_s390_init(void)
5027 if (!sclp
.has_sief2
) {
5028 pr_info("SIE is not available\n");
5032 if (nested
&& hpage
) {
5033 pr_info("A KVM host that supports nesting cannot back its KVM guests with huge pages\n");
5037 for (i
= 0; i
< 16; i
++)
5038 kvm_s390_fac_base
[i
] |=
5039 S390_lowcore
.stfle_fac_list
[i
] & nonhyp_mask(i
);
5041 return kvm_init(NULL
, sizeof(struct kvm_vcpu
), 0, THIS_MODULE
);
5044 static void __exit
kvm_s390_exit(void)
5049 module_init(kvm_s390_init
);
5050 module_exit(kvm_s390_exit
);
5053 * Enable autoloading of the kvm module.
5054 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
5055 * since x86 takes a different approach.
5057 #include <linux/miscdevice.h>
5058 MODULE_ALIAS_MISCDEV(KVM_MINOR
);
5059 MODULE_ALIAS("devname:kvm");