1
2
3
4
5
6
7
8
9
10
11
12
13
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/system.h>
31#include "kvm-s390.h"
32#include "gaccess.h"
33
34#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
35
36struct kvm_stats_debugfs_item debugfs_entries[] = {
37 { "userspace_handled", VCPU_STAT(exit_userspace) },
38 { "exit_null", VCPU_STAT(exit_null) },
39 { "exit_validity", VCPU_STAT(exit_validity) },
40 { "exit_stop_request", VCPU_STAT(exit_stop_request) },
41 { "exit_external_request", VCPU_STAT(exit_external_request) },
42 { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
43 { "exit_instruction", VCPU_STAT(exit_instruction) },
44 { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
45 { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
46 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
47 { "instruction_lctl", VCPU_STAT(instruction_lctl) },
48 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
49 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
50 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
51 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
52 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
53 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
54 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
55 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
56 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
57 { "instruction_spx", VCPU_STAT(instruction_spx) },
58 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
59 { "instruction_stap", VCPU_STAT(instruction_stap) },
60 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
61 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
62 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
63 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
64 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
65 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
66 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
67 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
68 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
69 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
70 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
71 { "diagnose_44", VCPU_STAT(diagnose_44) },
72 { NULL }
73};
74
75static unsigned long long *facilities;
76
77
78int kvm_arch_hardware_enable(void *garbage)
79{
80
81 return 0;
82}
83
84void kvm_arch_hardware_disable(void *garbage)
85{
86}
87
88int kvm_arch_hardware_setup(void)
89{
90 return 0;
91}
92
93void kvm_arch_hardware_unsetup(void)
94{
95}
96
97void kvm_arch_check_processor_compat(void *rtn)
98{
99}
100
101int kvm_arch_init(void *opaque)
102{
103 return 0;
104}
105
106void kvm_arch_exit(void)
107{
108}
109
110
111long kvm_arch_dev_ioctl(struct file *filp,
112 unsigned int ioctl, unsigned long arg)
113{
114 if (ioctl == KVM_S390_ENABLE_SIE)
115 return s390_enable_sie();
116 return -EINVAL;
117}
118
119int kvm_dev_ioctl_check_extension(long ext)
120{
121 int r;
122
123 switch (ext) {
124 case KVM_CAP_S390_PSW:
125 r = 1;
126 break;
127 default:
128 r = 0;
129 }
130 return r;
131}
132
133
134
135
136
137int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
138 struct kvm_dirty_log *log)
139{
140 return 0;
141}
142
143long kvm_arch_vm_ioctl(struct file *filp,
144 unsigned int ioctl, unsigned long arg)
145{
146 struct kvm *kvm = filp->private_data;
147 void __user *argp = (void __user *)arg;
148 int r;
149
150 switch (ioctl) {
151 case KVM_S390_INTERRUPT: {
152 struct kvm_s390_interrupt s390int;
153
154 r = -EFAULT;
155 if (copy_from_user(&s390int, argp, sizeof(s390int)))
156 break;
157 r = kvm_s390_inject_vm(kvm, &s390int);
158 break;
159 }
160 default:
161 r = -ENOTTY;
162 }
163
164 return r;
165}
166
167int kvm_arch_init_vm(struct kvm *kvm)
168{
169 int rc;
170 char debug_name[16];
171
172 rc = s390_enable_sie();
173 if (rc)
174 goto out_err;
175
176 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
177 if (!kvm->arch.sca)
178 goto out_err;
179
180 sprintf(debug_name, "kvm-%u", current->pid);
181
182 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
183 if (!kvm->arch.dbf)
184 goto out_nodbf;
185
186 spin_lock_init(&kvm->arch.float_int.lock);
187 INIT_LIST_HEAD(&kvm->arch.float_int.list);
188
189 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
190 VM_EVENT(kvm, 3, "%s", "vm created");
191
192 return 0;
193out_nodbf:
194 free_page((unsigned long)(kvm->arch.sca));
195out_err:
196 return rc;
197}
198
199void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
200{
201 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
202 clear_bit(63 - vcpu->vcpu_id, (unsigned long *) &vcpu->kvm->arch.sca->mcn);
203 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
204 (__u64) vcpu->arch.sie_block)
205 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
206 smp_mb();
207 free_page((unsigned long)(vcpu->arch.sie_block));
208 kvm_vcpu_uninit(vcpu);
209 kfree(vcpu);
210}
211
212static void kvm_free_vcpus(struct kvm *kvm)
213{
214 unsigned int i;
215 struct kvm_vcpu *vcpu;
216
217 kvm_for_each_vcpu(i, vcpu, kvm)
218 kvm_arch_vcpu_destroy(vcpu);
219
220 mutex_lock(&kvm->lock);
221 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
222 kvm->vcpus[i] = NULL;
223
224 atomic_set(&kvm->online_vcpus, 0);
225 mutex_unlock(&kvm->lock);
226}
227
228void kvm_arch_sync_events(struct kvm *kvm)
229{
230}
231
232void kvm_arch_destroy_vm(struct kvm *kvm)
233{
234 kvm_free_vcpus(kvm);
235 free_page((unsigned long)(kvm->arch.sca));
236 debug_unregister(kvm->arch.dbf);
237}
238
239
240int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
241{
242 return 0;
243}
244
245void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
246{
247
248}
249
250void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
251{
252 save_fp_regs(&vcpu->arch.host_fpregs);
253 save_access_regs(vcpu->arch.host_acrs);
254 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
255 restore_fp_regs(&vcpu->arch.guest_fpregs);
256 restore_access_regs(vcpu->arch.guest_acrs);
257}
258
259void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
260{
261 save_fp_regs(&vcpu->arch.guest_fpregs);
262 save_access_regs(vcpu->arch.guest_acrs);
263 restore_fp_regs(&vcpu->arch.host_fpregs);
264 restore_access_regs(vcpu->arch.host_acrs);
265}
266
267static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
268{
269
270 vcpu->arch.sie_block->gpsw.mask = 0UL;
271 vcpu->arch.sie_block->gpsw.addr = 0UL;
272 vcpu->arch.sie_block->prefix = 0UL;
273 vcpu->arch.sie_block->ihcpu = 0xffff;
274 vcpu->arch.sie_block->cputm = 0UL;
275 vcpu->arch.sie_block->ckc = 0UL;
276 vcpu->arch.sie_block->todpr = 0;
277 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
278 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
279 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
280 vcpu->arch.guest_fpregs.fpc = 0;
281 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
282 vcpu->arch.sie_block->gbea = 1;
283}
284
285int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
286{
287 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH);
288 set_bit(KVM_REQ_MMU_RELOAD, &vcpu->requests);
289 vcpu->arch.sie_block->ecb = 6;
290 vcpu->arch.sie_block->eca = 0xC1002001U;
291 vcpu->arch.sie_block->fac = (int) (long) facilities;
292 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
293 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
294 (unsigned long) vcpu);
295 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
296 get_cpu_id(&vcpu->arch.cpu_id);
297 vcpu->arch.cpu_id.version = 0xff;
298 return 0;
299}
300
301struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
302 unsigned int id)
303{
304 struct kvm_vcpu *vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
305 int rc = -ENOMEM;
306
307 if (!vcpu)
308 goto out_nomem;
309
310 vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
311 get_zeroed_page(GFP_KERNEL);
312
313 if (!vcpu->arch.sie_block)
314 goto out_free_cpu;
315
316 vcpu->arch.sie_block->icpua = id;
317 BUG_ON(!kvm->arch.sca);
318 if (!kvm->arch.sca->cpu[id].sda)
319 kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block;
320 vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32);
321 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
322 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
323
324 spin_lock_init(&vcpu->arch.local_int.lock);
325 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
326 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
327 spin_lock(&kvm->arch.float_int.lock);
328 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
329 init_waitqueue_head(&vcpu->arch.local_int.wq);
330 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
331 spin_unlock(&kvm->arch.float_int.lock);
332
333 rc = kvm_vcpu_init(vcpu, kvm, id);
334 if (rc)
335 goto out_free_sie_block;
336 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
337 vcpu->arch.sie_block);
338
339 return vcpu;
340out_free_sie_block:
341 free_page((unsigned long)(vcpu->arch.sie_block));
342out_free_cpu:
343 kfree(vcpu);
344out_nomem:
345 return ERR_PTR(rc);
346}
347
348int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
349{
350
351 BUG();
352 return 0;
353}
354
355static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
356{
357 kvm_s390_vcpu_initial_reset(vcpu);
358 return 0;
359}
360
361int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
362{
363 memcpy(&vcpu->arch.guest_gprs, ®s->gprs, sizeof(regs->gprs));
364 return 0;
365}
366
367int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
368{
369 memcpy(®s->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs));
370 return 0;
371}
372
373int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
374 struct kvm_sregs *sregs)
375{
376 memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs));
377 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
378 return 0;
379}
380
381int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
382 struct kvm_sregs *sregs)
383{
384 memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs));
385 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
386 return 0;
387}
388
389int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
390{
391 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
392 vcpu->arch.guest_fpregs.fpc = fpu->fpc;
393 return 0;
394}
395
396int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
397{
398 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
399 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
400 return 0;
401}
402
403static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
404{
405 int rc = 0;
406
407 if (atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_RUNNING)
408 rc = -EBUSY;
409 else {
410 vcpu->run->psw_mask = psw.mask;
411 vcpu->run->psw_addr = psw.addr;
412 }
413 return rc;
414}
415
416int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
417 struct kvm_translation *tr)
418{
419 return -EINVAL;
420}
421
422int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
423 struct kvm_guest_debug *dbg)
424{
425 return -EINVAL;
426}
427
428int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
429 struct kvm_mp_state *mp_state)
430{
431 return -EINVAL;
432}
433
434int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
435 struct kvm_mp_state *mp_state)
436{
437 return -EINVAL;
438}
439
440static void __vcpu_run(struct kvm_vcpu *vcpu)
441{
442 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16);
443
444 if (need_resched())
445 schedule();
446
447 if (test_thread_flag(TIF_MCCK_PENDING))
448 s390_handle_mcck();
449
450 kvm_s390_deliver_pending_interrupts(vcpu);
451
452 vcpu->arch.sie_block->icptcode = 0;
453 local_irq_disable();
454 kvm_guest_enter();
455 local_irq_enable();
456 VCPU_EVENT(vcpu, 6, "entering sie flags %x",
457 atomic_read(&vcpu->arch.sie_block->cpuflags));
458 if (sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs)) {
459 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
460 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
461 }
462 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
463 vcpu->arch.sie_block->icptcode);
464 local_irq_disable();
465 kvm_guest_exit();
466 local_irq_enable();
467
468 memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16);
469}
470
471int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
472{
473 int rc;
474 sigset_t sigsaved;
475
476rerun_vcpu:
477 if (vcpu->requests)
478 if (test_and_clear_bit(KVM_REQ_MMU_RELOAD, &vcpu->requests))
479 kvm_s390_vcpu_set_mem(vcpu);
480
481
482 if (!vcpu->arch.sie_block->gmslm) {
483 vcpu_put(vcpu);
484 VCPU_EVENT(vcpu, 3, "%s", "no memory registered to run vcpu");
485 return -EINVAL;
486 }
487
488 if (vcpu->sigset_active)
489 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
490
491 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
492
493 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
494
495 switch (kvm_run->exit_reason) {
496 case KVM_EXIT_S390_SIEIC:
497 case KVM_EXIT_UNKNOWN:
498 case KVM_EXIT_INTR:
499 case KVM_EXIT_S390_RESET:
500 break;
501 default:
502 BUG();
503 }
504
505 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
506 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
507
508 might_fault();
509
510 do {
511 __vcpu_run(vcpu);
512 rc = kvm_handle_sie_intercept(vcpu);
513 } while (!signal_pending(current) && !rc);
514
515 if (rc == SIE_INTERCEPT_RERUNVCPU)
516 goto rerun_vcpu;
517
518 if (signal_pending(current) && !rc) {
519 kvm_run->exit_reason = KVM_EXIT_INTR;
520 rc = -EINTR;
521 }
522
523 if (rc == -EOPNOTSUPP) {
524
525 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
526 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
527 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
528 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
529 rc = 0;
530 }
531
532 if (rc == -EREMOTE) {
533
534
535 rc = 0;
536 }
537
538 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
539 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
540
541 if (vcpu->sigset_active)
542 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
543
544 vcpu->stat.exit_userspace++;
545 return rc;
546}
547
548static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, const void *from,
549 unsigned long n, int prefix)
550{
551 if (prefix)
552 return copy_to_guest(vcpu, guestdest, from, n);
553 else
554 return copy_to_guest_absolute(vcpu, guestdest, from, n);
555}
556
557
558
559
560
561
562
563int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
564{
565 const unsigned char archmode = 1;
566 int prefix;
567
568 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
569 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
570 return -EFAULT;
571 addr = SAVE_AREA_BASE;
572 prefix = 0;
573 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
574 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
575 return -EFAULT;
576 addr = SAVE_AREA_BASE;
577 prefix = 1;
578 } else
579 prefix = 0;
580
581 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
582 vcpu->arch.guest_fpregs.fprs, 128, prefix))
583 return -EFAULT;
584
585 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
586 vcpu->arch.guest_gprs, 128, prefix))
587 return -EFAULT;
588
589 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
590 &vcpu->arch.sie_block->gpsw, 16, prefix))
591 return -EFAULT;
592
593 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
594 &vcpu->arch.sie_block->prefix, 4, prefix))
595 return -EFAULT;
596
597 if (__guestcopy(vcpu,
598 addr + offsetof(struct save_area, fp_ctrl_reg),
599 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
600 return -EFAULT;
601
602 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
603 &vcpu->arch.sie_block->todpr, 4, prefix))
604 return -EFAULT;
605
606 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
607 &vcpu->arch.sie_block->cputm, 8, prefix))
608 return -EFAULT;
609
610 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
611 &vcpu->arch.sie_block->ckc, 8, prefix))
612 return -EFAULT;
613
614 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
615 &vcpu->arch.guest_acrs, 64, prefix))
616 return -EFAULT;
617
618 if (__guestcopy(vcpu,
619 addr + offsetof(struct save_area, ctrl_regs),
620 &vcpu->arch.sie_block->gcr, 128, prefix))
621 return -EFAULT;
622 return 0;
623}
624
625long kvm_arch_vcpu_ioctl(struct file *filp,
626 unsigned int ioctl, unsigned long arg)
627{
628 struct kvm_vcpu *vcpu = filp->private_data;
629 void __user *argp = (void __user *)arg;
630 long r;
631
632 switch (ioctl) {
633 case KVM_S390_INTERRUPT: {
634 struct kvm_s390_interrupt s390int;
635
636 r = -EFAULT;
637 if (copy_from_user(&s390int, argp, sizeof(s390int)))
638 break;
639 r = kvm_s390_inject_vcpu(vcpu, &s390int);
640 break;
641 }
642 case KVM_S390_STORE_STATUS:
643 r = kvm_s390_vcpu_store_status(vcpu, arg);
644 break;
645 case KVM_S390_SET_INITIAL_PSW: {
646 psw_t psw;
647
648 r = -EFAULT;
649 if (copy_from_user(&psw, argp, sizeof(psw)))
650 break;
651 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
652 break;
653 }
654 case KVM_S390_INITIAL_RESET:
655 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
656 break;
657 default:
658 r = -EINVAL;
659 }
660 return r;
661}
662
663
664int kvm_arch_prepare_memory_region(struct kvm *kvm,
665 struct kvm_memory_slot *memslot,
666 struct kvm_memory_slot old,
667 struct kvm_userspace_memory_region *mem,
668 int user_alloc)
669{
670
671
672
673
674
675
676
677 if (mem->slot)
678 return -EINVAL;
679
680 if (mem->guest_phys_addr)
681 return -EINVAL;
682
683 if (mem->userspace_addr & (PAGE_SIZE - 1))
684 return -EINVAL;
685
686 if (mem->memory_size & (PAGE_SIZE - 1))
687 return -EINVAL;
688
689 if (!user_alloc)
690 return -EINVAL;
691
692 return 0;
693}
694
695void kvm_arch_commit_memory_region(struct kvm *kvm,
696 struct kvm_userspace_memory_region *mem,
697 struct kvm_memory_slot old,
698 int user_alloc)
699{
700 int i;
701 struct kvm_vcpu *vcpu;
702
703
704 kvm_for_each_vcpu(i, vcpu, kvm) {
705 if (test_and_set_bit(KVM_REQ_MMU_RELOAD, &vcpu->requests))
706 continue;
707 kvm_s390_inject_sigp_stop(vcpu, ACTION_RELOADVCPU_ON_STOP);
708 }
709}
710
711void kvm_arch_flush_shadow(struct kvm *kvm)
712{
713}
714
715static int __init kvm_s390_init(void)
716{
717 int ret;
718 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
719 if (ret)
720 return ret;
721
722
723
724
725
726
727 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
728 if (!facilities) {
729 kvm_exit();
730 return -ENOMEM;
731 }
732 memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
733 facilities[0] &= 0xff00fff3f47c0000ULL;
734 return 0;
735}
736
737static void __exit kvm_s390_exit(void)
738{
739 free_page((unsigned long) facilities);
740 kvm_exit();
741}
742
743module_init(kvm_s390_init);
744module_exit(kvm_s390_exit);
745