]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - arch/s390/kvm/kvm-s390.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


08227c1e816fc8c0b9fa8caaeeec35c8ff5d30ff
[mirror_ubuntu-bionic-kernel.git] / arch / s390 / kvm / kvm-s390.c
1 /*
2 * hosting zSeries kernel virtual machines
3 *
4 * Copyright IBM Corp. 2008, 2009
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License (version 2 only)
8 * as published by the Free Software Foundation.
9 *
10 * Author(s): Carsten Otte <cotte@de.ibm.com>
11 * Christian Borntraeger <borntraeger@de.ibm.com>
12 * Heiko Carstens <heiko.carstens@de.ibm.com>
13 * Christian Ehrhardt <ehrhardt@de.ibm.com>
14 */
15
16 #include <linux/compiler.h>
17 #include <linux/err.h>
18 #include <linux/fs.h>
19 #include <linux/hrtimer.h>
20 #include <linux/init.h>
21 #include <linux/kvm.h>
22 #include <linux/kvm_host.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/timer.h>
26 #include <asm/asm-offsets.h>
27 #include <asm/lowcore.h>
28 #include <asm/pgtable.h>
29 #include <asm/nmi.h>
30 #include <asm/switch_to.h>
31 #include <asm/sclp.h>
32 #include "kvm-s390.h"
33 #include "gaccess.h"
34
35 #define CREATE_TRACE_POINTS
36 #include "trace.h"
37 #include "trace-s390.h"
38
39 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
40
41 struct kvm_stats_debugfs_item debugfs_entries[] = {
42 { "userspace_handled", VCPU_STAT(exit_userspace) },
43 { "exit_null", VCPU_STAT(exit_null) },
44 { "exit_validity", VCPU_STAT(exit_validity) },
45 { "exit_stop_request", VCPU_STAT(exit_stop_request) },
46 { "exit_external_request", VCPU_STAT(exit_external_request) },
47 { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
48 { "exit_instruction", VCPU_STAT(exit_instruction) },
49 { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
50 { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
51 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
52 { "instruction_lctl", VCPU_STAT(instruction_lctl) },
53 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
54 { "deliver_external_call", VCPU_STAT(deliver_external_call) },
55 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
56 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
57 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
58 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
59 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
60 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
61 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
62 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
63 { "instruction_spx", VCPU_STAT(instruction_spx) },
64 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
65 { "instruction_stap", VCPU_STAT(instruction_stap) },
66 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
67 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
68 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
69 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
70 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
71 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
72 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
73 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
74 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
75 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
76 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
77 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
78 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
79 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
80 { "diagnose_10", VCPU_STAT(diagnose_10) },
81 { "diagnose_44", VCPU_STAT(diagnose_44) },
82 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
83 { NULL }
84 };
85
86 static unsigned long long *facilities;
87 static struct gmap_notifier gmap_notifier;
88
89 /* Section: not file related */
90 int kvm_arch_hardware_enable(void *garbage)
91 {
92 /* every s390 is virtualization enabled ;-) */
93 return 0;
94 }
95
96 void kvm_arch_hardware_disable(void *garbage)
97 {
98 }
99
100 static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);
101
102 int kvm_arch_hardware_setup(void)
103 {
104 gmap_notifier.notifier_call = kvm_gmap_notifier;
105 gmap_register_ipte_notifier(&gmap_notifier);
106 return 0;
107 }
108
109 void kvm_arch_hardware_unsetup(void)
110 {
111 gmap_unregister_ipte_notifier(&gmap_notifier);
112 }
113
114 void kvm_arch_check_processor_compat(void *rtn)
115 {
116 }
117
118 int kvm_arch_init(void *opaque)
119 {
120 return 0;
121 }
122
123 void kvm_arch_exit(void)
124 {
125 }
126
127 /* Section: device related */
128 long kvm_arch_dev_ioctl(struct file *filp,
129 unsigned int ioctl, unsigned long arg)
130 {
131 if (ioctl == KVM_S390_ENABLE_SIE)
132 return s390_enable_sie();
133 return -EINVAL;
134 }
135
136 int kvm_dev_ioctl_check_extension(long ext)
137 {
138 int r;
139
140 switch (ext) {
141 case KVM_CAP_S390_PSW:
142 case KVM_CAP_S390_GMAP:
143 case KVM_CAP_SYNC_MMU:
144 #ifdef CONFIG_KVM_S390_UCONTROL
145 case KVM_CAP_S390_UCONTROL:
146 #endif
147 case KVM_CAP_SYNC_REGS:
148 case KVM_CAP_ONE_REG:
149 case KVM_CAP_ENABLE_CAP:
150 case KVM_CAP_S390_CSS_SUPPORT:
151 case KVM_CAP_IOEVENTFD:
152 r = 1;
153 break;
154 case KVM_CAP_NR_VCPUS:
155 case KVM_CAP_MAX_VCPUS:
156 r = KVM_MAX_VCPUS;
157 break;
158 case KVM_CAP_NR_MEMSLOTS:
159 r = KVM_USER_MEM_SLOTS;
160 break;
161 case KVM_CAP_S390_COW:
162 r = MACHINE_HAS_ESOP;
163 break;
164 default:
165 r = 0;
166 }
167 return r;
168 }
169
170 /* Section: vm related */
171 /*
172 * Get (and clear) the dirty memory log for a memory slot.
173 */
174 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
175 struct kvm_dirty_log *log)
176 {
177 return 0;
178 }
179
180 long kvm_arch_vm_ioctl(struct file *filp,
181 unsigned int ioctl, unsigned long arg)
182 {
183 struct kvm *kvm = filp->private_data;
184 void __user *argp = (void __user *)arg;
185 int r;
186
187 switch (ioctl) {
188 case KVM_S390_INTERRUPT: {
189 struct kvm_s390_interrupt s390int;
190
191 r = -EFAULT;
192 if (copy_from_user(&s390int, argp, sizeof(s390int)))
193 break;
194 r = kvm_s390_inject_vm(kvm, &s390int);
195 break;
196 }
197 default:
198 r = -ENOTTY;
199 }
200
201 return r;
202 }
203
204 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
205 {
206 int rc;
207 char debug_name[16];
208
209 rc = -EINVAL;
210 #ifdef CONFIG_KVM_S390_UCONTROL
211 if (type & ~KVM_VM_S390_UCONTROL)
212 goto out_err;
213 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
214 goto out_err;
215 #else
216 if (type)
217 goto out_err;
218 #endif
219
220 rc = s390_enable_sie();
221 if (rc)
222 goto out_err;
223
224 rc = -ENOMEM;
225
226 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
227 if (!kvm->arch.sca)
228 goto out_err;
229
230 sprintf(debug_name, "kvm-%u", current->pid);
231
232 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
233 if (!kvm->arch.dbf)
234 goto out_nodbf;
235
236 spin_lock_init(&kvm->arch.float_int.lock);
237 INIT_LIST_HEAD(&kvm->arch.float_int.list);
238
239 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
240 VM_EVENT(kvm, 3, "%s", "vm created");
241
242 if (type & KVM_VM_S390_UCONTROL) {
243 kvm->arch.gmap = NULL;
244 } else {
245 kvm->arch.gmap = gmap_alloc(current->mm);
246 if (!kvm->arch.gmap)
247 goto out_nogmap;
248 kvm->arch.gmap->private = kvm;
249 }
250
251 kvm->arch.css_support = 0;
252
253 return 0;
254 out_nogmap:
255 debug_unregister(kvm->arch.dbf);
256 out_nodbf:
257 free_page((unsigned long)(kvm->arch.sca));
258 out_err:
259 return rc;
260 }
261
262 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
263 {
264 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
265 trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
266 if (!kvm_is_ucontrol(vcpu->kvm)) {
267 clear_bit(63 - vcpu->vcpu_id,
268 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
269 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
270 (__u64) vcpu->arch.sie_block)
271 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
272 }
273 smp_mb();
274
275 if (kvm_is_ucontrol(vcpu->kvm))
276 gmap_free(vcpu->arch.gmap);
277
278 free_page((unsigned long)(vcpu->arch.sie_block));
279 kvm_vcpu_uninit(vcpu);
280 kfree(vcpu);
281 }
282
283 static void kvm_free_vcpus(struct kvm *kvm)
284 {
285 unsigned int i;
286 struct kvm_vcpu *vcpu;
287
288 kvm_for_each_vcpu(i, vcpu, kvm)
289 kvm_arch_vcpu_destroy(vcpu);
290
291 mutex_lock(&kvm->lock);
292 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
293 kvm->vcpus[i] = NULL;
294
295 atomic_set(&kvm->online_vcpus, 0);
296 mutex_unlock(&kvm->lock);
297 }
298
299 void kvm_arch_sync_events(struct kvm *kvm)
300 {
301 }
302
303 void kvm_arch_destroy_vm(struct kvm *kvm)
304 {
305 kvm_free_vcpus(kvm);
306 free_page((unsigned long)(kvm->arch.sca));
307 debug_unregister(kvm->arch.dbf);
308 if (!kvm_is_ucontrol(kvm))
309 gmap_free(kvm->arch.gmap);
310 }
311
312 /* Section: vcpu related */
313 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
314 {
315 if (kvm_is_ucontrol(vcpu->kvm)) {
316 vcpu->arch.gmap = gmap_alloc(current->mm);
317 if (!vcpu->arch.gmap)
318 return -ENOMEM;
319 vcpu->arch.gmap->private = vcpu->kvm;
320 return 0;
321 }
322
323 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
324 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
325 KVM_SYNC_GPRS |
326 KVM_SYNC_ACRS |
327 KVM_SYNC_CRS;
328 return 0;
329 }
330
331 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
332 {
333 /* Nothing todo */
334 }
335
336 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
337 {
338 save_fp_regs(&vcpu->arch.host_fpregs);
339 save_access_regs(vcpu->arch.host_acrs);
340 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
341 restore_fp_regs(&vcpu->arch.guest_fpregs);
342 restore_access_regs(vcpu->run->s.regs.acrs);
343 gmap_enable(vcpu->arch.gmap);
344 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
345 }
346
347 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
348 {
349 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
350 gmap_disable(vcpu->arch.gmap);
351 save_fp_regs(&vcpu->arch.guest_fpregs);
352 save_access_regs(vcpu->run->s.regs.acrs);
353 restore_fp_regs(&vcpu->arch.host_fpregs);
354 restore_access_regs(vcpu->arch.host_acrs);
355 }
356
357 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
358 {
359 /* this equals initial cpu reset in pop, but we don't switch to ESA */
360 vcpu->arch.sie_block->gpsw.mask = 0UL;
361 vcpu->arch.sie_block->gpsw.addr = 0UL;
362 kvm_s390_set_prefix(vcpu, 0);
363 vcpu->arch.sie_block->cputm = 0UL;
364 vcpu->arch.sie_block->ckc = 0UL;
365 vcpu->arch.sie_block->todpr = 0;
366 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
367 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
368 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
369 vcpu->arch.guest_fpregs.fpc = 0;
370 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
371 vcpu->arch.sie_block->gbea = 1;
372 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
373 }
374
375 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
376 {
377 return 0;
378 }
379
380 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
381 {
382 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
383 CPUSTAT_SM |
384 CPUSTAT_STOPPED);
385 vcpu->arch.sie_block->ecb = 6;
386 vcpu->arch.sie_block->eca = 0xC1002001U;
387 vcpu->arch.sie_block->fac = (int) (long) facilities;
388 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
389 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
390 (unsigned long) vcpu);
391 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
392 get_cpu_id(&vcpu->arch.cpu_id);
393 vcpu->arch.cpu_id.version = 0xff;
394 return 0;
395 }
396
397 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
398 unsigned int id)
399 {
400 struct kvm_vcpu *vcpu;
401 int rc = -EINVAL;
402
403 if (id >= KVM_MAX_VCPUS)
404 goto out;
405
406 rc = -ENOMEM;
407
408 vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
409 if (!vcpu)
410 goto out;
411
412 vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
413 get_zeroed_page(GFP_KERNEL);
414
415 if (!vcpu->arch.sie_block)
416 goto out_free_cpu;
417
418 vcpu->arch.sie_block->icpua = id;
419 if (!kvm_is_ucontrol(kvm)) {
420 if (!kvm->arch.sca) {
421 WARN_ON_ONCE(1);
422 goto out_free_cpu;
423 }
424 if (!kvm->arch.sca->cpu[id].sda)
425 kvm->arch.sca->cpu[id].sda =
426 (__u64) vcpu->arch.sie_block;
427 vcpu->arch.sie_block->scaoh =
428 (__u32)(((__u64)kvm->arch.sca) >> 32);
429 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
430 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
431 }
432
433 spin_lock_init(&vcpu->arch.local_int.lock);
434 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
435 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
436 spin_lock(&kvm->arch.float_int.lock);
437 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
438 init_waitqueue_head(&vcpu->arch.local_int.wq);
439 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
440 spin_unlock(&kvm->arch.float_int.lock);
441
442 rc = kvm_vcpu_init(vcpu, kvm, id);
443 if (rc)
444 goto out_free_sie_block;
445 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
446 vcpu->arch.sie_block);
447 trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
448
449 return vcpu;
450 out_free_sie_block:
451 free_page((unsigned long)(vcpu->arch.sie_block));
452 out_free_cpu:
453 kfree(vcpu);
454 out:
455 return ERR_PTR(rc);
456 }
457
458 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
459 {
460 /* kvm common code refers to this, but never calls it */
461 BUG();
462 return 0;
463 }
464
465 void s390_vcpu_block(struct kvm_vcpu *vcpu)
466 {
467 atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
468 }
469
470 void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
471 {
472 atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
473 }
474
475 /*
476 * Kick a guest cpu out of SIE and wait until SIE is not running.
477 * If the CPU is not running (e.g. waiting as idle) the function will
478 * return immediately. */
479 void exit_sie(struct kvm_vcpu *vcpu)
480 {
481 atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
482 while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
483 cpu_relax();
484 }
485
486 /* Kick a guest cpu out of SIE and prevent SIE-reentry */
487 void exit_sie_sync(struct kvm_vcpu *vcpu)
488 {
489 s390_vcpu_block(vcpu);
490 exit_sie(vcpu);
491 }
492
493 static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
494 {
495 int i;
496 struct kvm *kvm = gmap->private;
497 struct kvm_vcpu *vcpu;
498
499 kvm_for_each_vcpu(i, vcpu, kvm) {
500 /* match against both prefix pages */
501 if (vcpu->arch.sie_block->prefix == (address & ~0x1000UL)) {
502 VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
503 kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
504 exit_sie_sync(vcpu);
505 }
506 }
507 }
508
509 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
510 {
511 /* kvm common code refers to this, but never calls it */
512 BUG();
513 return 0;
514 }
515
516 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
517 struct kvm_one_reg *reg)
518 {
519 int r = -EINVAL;
520
521 switch (reg->id) {
522 case KVM_REG_S390_TODPR:
523 r = put_user(vcpu->arch.sie_block->todpr,
524 (u32 __user *)reg->addr);
525 break;
526 case KVM_REG_S390_EPOCHDIFF:
527 r = put_user(vcpu->arch.sie_block->epoch,
528 (u64 __user *)reg->addr);
529 break;
530 case KVM_REG_S390_CPU_TIMER:
531 r = put_user(vcpu->arch.sie_block->cputm,
532 (u64 __user *)reg->addr);
533 break;
534 case KVM_REG_S390_CLOCK_COMP:
535 r = put_user(vcpu->arch.sie_block->ckc,
536 (u64 __user *)reg->addr);
537 break;
538 default:
539 break;
540 }
541
542 return r;
543 }
544
545 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
546 struct kvm_one_reg *reg)
547 {
548 int r = -EINVAL;
549
550 switch (reg->id) {
551 case KVM_REG_S390_TODPR:
552 r = get_user(vcpu->arch.sie_block->todpr,
553 (u32 __user *)reg->addr);
554 break;
555 case KVM_REG_S390_EPOCHDIFF:
556 r = get_user(vcpu->arch.sie_block->epoch,
557 (u64 __user *)reg->addr);
558 break;
559 case KVM_REG_S390_CPU_TIMER:
560 r = get_user(vcpu->arch.sie_block->cputm,
561 (u64 __user *)reg->addr);
562 break;
563 case KVM_REG_S390_CLOCK_COMP:
564 r = get_user(vcpu->arch.sie_block->ckc,
565 (u64 __user *)reg->addr);
566 break;
567 default:
568 break;
569 }
570
571 return r;
572 }
573
574 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
575 {
576 kvm_s390_vcpu_initial_reset(vcpu);
577 return 0;
578 }
579
580 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
581 {
582 memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
583 return 0;
584 }
585
586 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
587 {
588 memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
589 return 0;
590 }
591
592 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
593 struct kvm_sregs *sregs)
594 {
595 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
596 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
597 restore_access_regs(vcpu->run->s.regs.acrs);
598 return 0;
599 }
600
601 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
602 struct kvm_sregs *sregs)
603 {
604 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
605 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
606 return 0;
607 }
608
609 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
610 {
611 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
612 vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK;
613 restore_fp_regs(&vcpu->arch.guest_fpregs);
614 return 0;
615 }
616
617 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
618 {
619 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
620 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
621 return 0;
622 }
623
624 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
625 {
626 int rc = 0;
627
628 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
629 rc = -EBUSY;
630 else {
631 vcpu->run->psw_mask = psw.mask;
632 vcpu->run->psw_addr = psw.addr;
633 }
634 return rc;
635 }
636
637 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
638 struct kvm_translation *tr)
639 {
640 return -EINVAL; /* not implemented yet */
641 }
642
643 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
644 struct kvm_guest_debug *dbg)
645 {
646 return -EINVAL; /* not implemented yet */
647 }
648
649 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
650 struct kvm_mp_state *mp_state)
651 {
652 return -EINVAL; /* not implemented yet */
653 }
654
655 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
656 struct kvm_mp_state *mp_state)
657 {
658 return -EINVAL; /* not implemented yet */
659 }
660
661 static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
662 {
663 /*
664 * We use MMU_RELOAD just to re-arm the ipte notifier for the
665 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
666 * This ensures that the ipte instruction for this request has
667 * already finished. We might race against a second unmapper that
668 * wants to set the blocking bit. Lets just retry the request loop.
669 */
670 while (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
671 int rc;
672 rc = gmap_ipte_notify(vcpu->arch.gmap,
673 vcpu->arch.sie_block->prefix,
674 PAGE_SIZE * 2);
675 if (rc)
676 return rc;
677 s390_vcpu_unblock(vcpu);
678 }
679 return 0;
680 }
681
682 static int __vcpu_run(struct kvm_vcpu *vcpu)
683 {
684 int rc;
685
686 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
687
688 if (need_resched())
689 schedule();
690
691 if (test_thread_flag(TIF_MCCK_PENDING))
692 s390_handle_mcck();
693
694 if (!kvm_is_ucontrol(vcpu->kvm))
695 kvm_s390_deliver_pending_interrupts(vcpu);
696
697 rc = kvm_s390_handle_requests(vcpu);
698 if (rc)
699 return rc;
700
701 vcpu->arch.sie_block->icptcode = 0;
702 preempt_disable();
703 kvm_guest_enter();
704 preempt_enable();
705 VCPU_EVENT(vcpu, 6, "entering sie flags %x",
706 atomic_read(&vcpu->arch.sie_block->cpuflags));
707 trace_kvm_s390_sie_enter(vcpu,
708 atomic_read(&vcpu->arch.sie_block->cpuflags));
709 rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
710 if (rc) {
711 if (kvm_is_ucontrol(vcpu->kvm)) {
712 rc = SIE_INTERCEPT_UCONTROL;
713 } else {
714 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
715 trace_kvm_s390_sie_fault(vcpu);
716 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
717 }
718 }
719 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
720 vcpu->arch.sie_block->icptcode);
721 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
722 kvm_guest_exit();
723
724 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
725 return rc;
726 }
727
728 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
729 {
730 int rc;
731 sigset_t sigsaved;
732
733 rerun_vcpu:
734 if (vcpu->sigset_active)
735 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
736
737 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
738
739 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
740
741 switch (kvm_run->exit_reason) {
742 case KVM_EXIT_S390_SIEIC:
743 case KVM_EXIT_UNKNOWN:
744 case KVM_EXIT_INTR:
745 case KVM_EXIT_S390_RESET:
746 case KVM_EXIT_S390_UCONTROL:
747 case KVM_EXIT_S390_TSCH:
748 break;
749 default:
750 BUG();
751 }
752
753 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
754 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
755 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
756 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
757 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
758 }
759 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
760 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
761 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
762 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
763 }
764
765 might_fault();
766
767 do {
768 rc = __vcpu_run(vcpu);
769 if (rc)
770 break;
771 if (kvm_is_ucontrol(vcpu->kvm))
772 rc = -EOPNOTSUPP;
773 else
774 rc = kvm_handle_sie_intercept(vcpu);
775 } while (!signal_pending(current) && !rc);
776
777 if (rc == SIE_INTERCEPT_RERUNVCPU)
778 goto rerun_vcpu;
779
780 if (signal_pending(current) && !rc) {
781 kvm_run->exit_reason = KVM_EXIT_INTR;
782 rc = -EINTR;
783 }
784
785 #ifdef CONFIG_KVM_S390_UCONTROL
786 if (rc == SIE_INTERCEPT_UCONTROL) {
787 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
788 kvm_run->s390_ucontrol.trans_exc_code =
789 current->thread.gmap_addr;
790 kvm_run->s390_ucontrol.pgm_code = 0x10;
791 rc = 0;
792 }
793 #endif
794
795 if (rc == -EOPNOTSUPP) {
796 /* intercept cannot be handled in-kernel, prepare kvm-run */
797 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
798 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
799 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
800 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
801 rc = 0;
802 }
803
804 if (rc == -EREMOTE) {
805 /* intercept was handled, but userspace support is needed
806 * kvm_run has been prepared by the handler */
807 rc = 0;
808 }
809
810 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
811 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
812 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
813 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
814
815 if (vcpu->sigset_active)
816 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
817
818 vcpu->stat.exit_userspace++;
819 return rc;
820 }
821
822 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
823 unsigned long n, int prefix)
824 {
825 if (prefix)
826 return copy_to_guest(vcpu, guestdest, from, n);
827 else
828 return copy_to_guest_absolute(vcpu, guestdest, from, n);
829 }
830
831 /*
832 * store status at address
833 * we use have two special cases:
834 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
835 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
836 */
837 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
838 {
839 unsigned char archmode = 1;
840 int prefix;
841
842 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
843 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
844 return -EFAULT;
845 addr = SAVE_AREA_BASE;
846 prefix = 0;
847 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
848 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
849 return -EFAULT;
850 addr = SAVE_AREA_BASE;
851 prefix = 1;
852 } else
853 prefix = 0;
854
855 /*
856 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
857 * copying in vcpu load/put. Lets update our copies before we save
858 * it into the save area
859 */
860 save_fp_regs(&vcpu->arch.guest_fpregs);
861 save_access_regs(vcpu->run->s.regs.acrs);
862
863 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
864 vcpu->arch.guest_fpregs.fprs, 128, prefix))
865 return -EFAULT;
866
867 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
868 vcpu->run->s.regs.gprs, 128, prefix))
869 return -EFAULT;
870
871 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
872 &vcpu->arch.sie_block->gpsw, 16, prefix))
873 return -EFAULT;
874
875 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
876 &vcpu->arch.sie_block->prefix, 4, prefix))
877 return -EFAULT;
878
879 if (__guestcopy(vcpu,
880 addr + offsetof(struct save_area, fp_ctrl_reg),
881 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
882 return -EFAULT;
883
884 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
885 &vcpu->arch.sie_block->todpr, 4, prefix))
886 return -EFAULT;
887
888 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
889 &vcpu->arch.sie_block->cputm, 8, prefix))
890 return -EFAULT;
891
892 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
893 &vcpu->arch.sie_block->ckc, 8, prefix))
894 return -EFAULT;
895
896 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
897 &vcpu->run->s.regs.acrs, 64, prefix))
898 return -EFAULT;
899
900 if (__guestcopy(vcpu,
901 addr + offsetof(struct save_area, ctrl_regs),
902 &vcpu->arch.sie_block->gcr, 128, prefix))
903 return -EFAULT;
904 return 0;
905 }
906
907 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
908 struct kvm_enable_cap *cap)
909 {
910 int r;
911
912 if (cap->flags)
913 return -EINVAL;
914
915 switch (cap->cap) {
916 case KVM_CAP_S390_CSS_SUPPORT:
917 if (!vcpu->kvm->arch.css_support) {
918 vcpu->kvm->arch.css_support = 1;
919 trace_kvm_s390_enable_css(vcpu->kvm);
920 }
921 r = 0;
922 break;
923 default:
924 r = -EINVAL;
925 break;
926 }
927 return r;
928 }
929
930 long kvm_arch_vcpu_ioctl(struct file *filp,
931 unsigned int ioctl, unsigned long arg)
932 {
933 struct kvm_vcpu *vcpu = filp->private_data;
934 void __user *argp = (void __user *)arg;
935 long r;
936
937 switch (ioctl) {
938 case KVM_S390_INTERRUPT: {
939 struct kvm_s390_interrupt s390int;
940
941 r = -EFAULT;
942 if (copy_from_user(&s390int, argp, sizeof(s390int)))
943 break;
944 r = kvm_s390_inject_vcpu(vcpu, &s390int);
945 break;
946 }
947 case KVM_S390_STORE_STATUS:
948 r = kvm_s390_vcpu_store_status(vcpu, arg);
949 break;
950 case KVM_S390_SET_INITIAL_PSW: {
951 psw_t psw;
952
953 r = -EFAULT;
954 if (copy_from_user(&psw, argp, sizeof(psw)))
955 break;
956 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
957 break;
958 }
959 case KVM_S390_INITIAL_RESET:
960 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
961 break;
962 case KVM_SET_ONE_REG:
963 case KVM_GET_ONE_REG: {
964 struct kvm_one_reg reg;
965 r = -EFAULT;
966 if (copy_from_user(&reg, argp, sizeof(reg)))
967 break;
968 if (ioctl == KVM_SET_ONE_REG)
969 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
970 else
971 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
972 break;
973 }
974 #ifdef CONFIG_KVM_S390_UCONTROL
975 case KVM_S390_UCAS_MAP: {
976 struct kvm_s390_ucas_mapping ucasmap;
977
978 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
979 r = -EFAULT;
980 break;
981 }
982
983 if (!kvm_is_ucontrol(vcpu->kvm)) {
984 r = -EINVAL;
985 break;
986 }
987
988 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
989 ucasmap.vcpu_addr, ucasmap.length);
990 break;
991 }
992 case KVM_S390_UCAS_UNMAP: {
993 struct kvm_s390_ucas_mapping ucasmap;
994
995 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
996 r = -EFAULT;
997 break;
998 }
999
1000 if (!kvm_is_ucontrol(vcpu->kvm)) {
1001 r = -EINVAL;
1002 break;
1003 }
1004
1005 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
1006 ucasmap.length);
1007 break;
1008 }
1009 #endif
1010 case KVM_S390_VCPU_FAULT: {
1011 r = gmap_fault(arg, vcpu->arch.gmap);
1012 if (!IS_ERR_VALUE(r))
1013 r = 0;
1014 break;
1015 }
1016 case KVM_ENABLE_CAP:
1017 {
1018 struct kvm_enable_cap cap;
1019 r = -EFAULT;
1020 if (copy_from_user(&cap, argp, sizeof(cap)))
1021 break;
1022 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1023 break;
1024 }
1025 default:
1026 r = -ENOTTY;
1027 }
1028 return r;
1029 }
1030
1031 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1032 {
1033 #ifdef CONFIG_KVM_S390_UCONTROL
1034 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
1035 && (kvm_is_ucontrol(vcpu->kvm))) {
1036 vmf->page = virt_to_page(vcpu->arch.sie_block);
1037 get_page(vmf->page);
1038 return 0;
1039 }
1040 #endif
1041 return VM_FAULT_SIGBUS;
1042 }
1043
1044 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
1045 struct kvm_memory_slot *dont)
1046 {
1047 }
1048
1049 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
1050 {
1051 return 0;
1052 }
1053
1054 /* Section: memory related */
1055 int kvm_arch_prepare_memory_region(struct kvm *kvm,
1056 struct kvm_memory_slot *memslot,
1057 struct kvm_userspace_memory_region *mem,
1058 enum kvm_mr_change change)
1059 {
1060 /* A few sanity checks. We can have memory slots which have to be
1061 located/ended at a segment boundary (1MB). The memory in userland is
1062 ok to be fragmented into various different vmas. It is okay to mmap()
1063 and munmap() stuff in this slot after doing this call at any time */
1064
1065 if (mem->userspace_addr & 0xffffful)
1066 return -EINVAL;
1067
1068 if (mem->memory_size & 0xffffful)
1069 return -EINVAL;
1070
1071 return 0;
1072 }
1073
1074 void kvm_arch_commit_memory_region(struct kvm *kvm,
1075 struct kvm_userspace_memory_region *mem,
1076 const struct kvm_memory_slot *old,
1077 enum kvm_mr_change change)
1078 {
1079 int rc;
1080
1081 /* If the basics of the memslot do not change, we do not want
1082 * to update the gmap. Every update causes several unnecessary
1083 * segment translation exceptions. This is usually handled just
1084 * fine by the normal fault handler + gmap, but it will also
1085 * cause faults on the prefix page of running guest CPUs.
1086 */
1087 if (old->userspace_addr == mem->userspace_addr &&
1088 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1089 old->npages * PAGE_SIZE == mem->memory_size)
1090 return;
1091
1092 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1093 mem->guest_phys_addr, mem->memory_size);
1094 if (rc)
1095 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
1096 return;
1097 }
1098
1099 void kvm_arch_flush_shadow_all(struct kvm *kvm)
1100 {
1101 }
1102
1103 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1104 struct kvm_memory_slot *slot)
1105 {
1106 }
1107
1108 static int __init kvm_s390_init(void)
1109 {
1110 int ret;
1111 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1112 if (ret)
1113 return ret;
1114
1115 /*
1116 * guests can ask for up to 255+1 double words, we need a full page
1117 * to hold the maximum amount of facilities. On the other hand, we
1118 * only set facilities that are known to work in KVM.
1119 */
1120 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1121 if (!facilities) {
1122 kvm_exit();
1123 return -ENOMEM;
1124 }
1125 memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
1126 facilities[0] &= 0xff00fff3f47c0000ULL;
1127 facilities[1] &= 0x001c000000000000ULL;
1128 return 0;
1129 }
1130
1131 static void __exit kvm_s390_exit(void)
1132 {
1133 free_page((unsigned long) facilities);
1134 kvm_exit();
1135 }
1136
1137 module_init(kvm_s390_init);
1138 module_exit(kvm_s390_exit);
ubuntu-bionic-kernel mirror