spi-topcliff-pch: Fix issue for transmitting over 4KByte
[zen-stable.git] / arch / s390 / kvm / kvm-s390.c
blobd3cb86c58c73c0f53d3be61789cbed94d0425b04
1 /*
2 * s390host.c -- hosting zSeries kernel virtual machines
4 * Copyright IBM Corp. 2008,2009
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.
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>
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"
34 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
36 struct 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_external_call", VCPU_STAT(deliver_external_call) },
50 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
51 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
52 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
53 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
54 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
55 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
56 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
57 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
58 { "instruction_spx", VCPU_STAT(instruction_spx) },
59 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
60 { "instruction_stap", VCPU_STAT(instruction_stap) },
61 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
62 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
63 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
64 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
65 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
66 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
67 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
68 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
69 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
70 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
71 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
72 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
73 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
74 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
75 { "diagnose_10", VCPU_STAT(diagnose_10) },
76 { "diagnose_44", VCPU_STAT(diagnose_44) },
77 { NULL }
80 static unsigned long long *facilities;
82 /* Section: not file related */
83 int kvm_arch_hardware_enable(void *garbage)
85 /* every s390 is virtualization enabled ;-) */
86 return 0;
89 void kvm_arch_hardware_disable(void *garbage)
93 int kvm_arch_hardware_setup(void)
95 return 0;
98 void kvm_arch_hardware_unsetup(void)
102 void kvm_arch_check_processor_compat(void *rtn)
106 int kvm_arch_init(void *opaque)
108 return 0;
111 void kvm_arch_exit(void)
115 /* Section: device related */
116 long kvm_arch_dev_ioctl(struct file *filp,
117 unsigned int ioctl, unsigned long arg)
119 if (ioctl == KVM_S390_ENABLE_SIE)
120 return s390_enable_sie();
121 return -EINVAL;
124 int kvm_dev_ioctl_check_extension(long ext)
126 int r;
128 switch (ext) {
129 case KVM_CAP_S390_PSW:
130 case KVM_CAP_S390_GMAP:
131 case KVM_CAP_SYNC_MMU:
132 r = 1;
133 break;
134 default:
135 r = 0;
137 return r;
140 /* Section: vm related */
142 * Get (and clear) the dirty memory log for a memory slot.
144 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
145 struct kvm_dirty_log *log)
147 return 0;
150 long kvm_arch_vm_ioctl(struct file *filp,
151 unsigned int ioctl, unsigned long arg)
153 struct kvm *kvm = filp->private_data;
154 void __user *argp = (void __user *)arg;
155 int r;
157 switch (ioctl) {
158 case KVM_S390_INTERRUPT: {
159 struct kvm_s390_interrupt s390int;
161 r = -EFAULT;
162 if (copy_from_user(&s390int, argp, sizeof(s390int)))
163 break;
164 r = kvm_s390_inject_vm(kvm, &s390int);
165 break;
167 default:
168 r = -ENOTTY;
171 return r;
174 int kvm_arch_init_vm(struct kvm *kvm)
176 int rc;
177 char debug_name[16];
179 rc = s390_enable_sie();
180 if (rc)
181 goto out_err;
183 rc = -ENOMEM;
185 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
186 if (!kvm->arch.sca)
187 goto out_err;
189 sprintf(debug_name, "kvm-%u", current->pid);
191 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
192 if (!kvm->arch.dbf)
193 goto out_nodbf;
195 spin_lock_init(&kvm->arch.float_int.lock);
196 INIT_LIST_HEAD(&kvm->arch.float_int.list);
198 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
199 VM_EVENT(kvm, 3, "%s", "vm created");
201 kvm->arch.gmap = gmap_alloc(current->mm);
202 if (!kvm->arch.gmap)
203 goto out_nogmap;
205 return 0;
206 out_nogmap:
207 debug_unregister(kvm->arch.dbf);
208 out_nodbf:
209 free_page((unsigned long)(kvm->arch.sca));
210 out_err:
211 return rc;
214 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
216 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
217 clear_bit(63 - vcpu->vcpu_id, (unsigned long *) &vcpu->kvm->arch.sca->mcn);
218 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
219 (__u64) vcpu->arch.sie_block)
220 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
221 smp_mb();
222 free_page((unsigned long)(vcpu->arch.sie_block));
223 kvm_vcpu_uninit(vcpu);
224 kfree(vcpu);
227 static void kvm_free_vcpus(struct kvm *kvm)
229 unsigned int i;
230 struct kvm_vcpu *vcpu;
232 kvm_for_each_vcpu(i, vcpu, kvm)
233 kvm_arch_vcpu_destroy(vcpu);
235 mutex_lock(&kvm->lock);
236 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
237 kvm->vcpus[i] = NULL;
239 atomic_set(&kvm->online_vcpus, 0);
240 mutex_unlock(&kvm->lock);
243 void kvm_arch_sync_events(struct kvm *kvm)
247 void kvm_arch_destroy_vm(struct kvm *kvm)
249 kvm_free_vcpus(kvm);
250 free_page((unsigned long)(kvm->arch.sca));
251 debug_unregister(kvm->arch.dbf);
252 gmap_free(kvm->arch.gmap);
255 /* Section: vcpu related */
256 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
258 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
259 return 0;
262 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
264 /* Nothing todo */
267 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
269 save_fp_regs(&vcpu->arch.host_fpregs);
270 save_access_regs(vcpu->arch.host_acrs);
271 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
272 restore_fp_regs(&vcpu->arch.guest_fpregs);
273 restore_access_regs(vcpu->arch.guest_acrs);
274 gmap_enable(vcpu->arch.gmap);
275 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
278 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
280 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
281 gmap_disable(vcpu->arch.gmap);
282 save_fp_regs(&vcpu->arch.guest_fpregs);
283 save_access_regs(vcpu->arch.guest_acrs);
284 restore_fp_regs(&vcpu->arch.host_fpregs);
285 restore_access_regs(vcpu->arch.host_acrs);
288 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
290 /* this equals initial cpu reset in pop, but we don't switch to ESA */
291 vcpu->arch.sie_block->gpsw.mask = 0UL;
292 vcpu->arch.sie_block->gpsw.addr = 0UL;
293 vcpu->arch.sie_block->prefix = 0UL;
294 vcpu->arch.sie_block->ihcpu = 0xffff;
295 vcpu->arch.sie_block->cputm = 0UL;
296 vcpu->arch.sie_block->ckc = 0UL;
297 vcpu->arch.sie_block->todpr = 0;
298 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
299 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
300 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
301 vcpu->arch.guest_fpregs.fpc = 0;
302 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
303 vcpu->arch.sie_block->gbea = 1;
306 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
308 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
309 CPUSTAT_SM |
310 CPUSTAT_STOPPED);
311 vcpu->arch.sie_block->ecb = 6;
312 vcpu->arch.sie_block->eca = 0xC1002001U;
313 vcpu->arch.sie_block->fac = (int) (long) facilities;
314 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
315 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
316 (unsigned long) vcpu);
317 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
318 get_cpu_id(&vcpu->arch.cpu_id);
319 vcpu->arch.cpu_id.version = 0xff;
320 return 0;
323 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
324 unsigned int id)
326 struct kvm_vcpu *vcpu;
327 int rc = -EINVAL;
329 if (id >= KVM_MAX_VCPUS)
330 goto out;
332 rc = -ENOMEM;
334 vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
335 if (!vcpu)
336 goto out;
338 vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
339 get_zeroed_page(GFP_KERNEL);
341 if (!vcpu->arch.sie_block)
342 goto out_free_cpu;
344 vcpu->arch.sie_block->icpua = id;
345 BUG_ON(!kvm->arch.sca);
346 if (!kvm->arch.sca->cpu[id].sda)
347 kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block;
348 vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32);
349 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
350 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
352 spin_lock_init(&vcpu->arch.local_int.lock);
353 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
354 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
355 spin_lock(&kvm->arch.float_int.lock);
356 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
357 init_waitqueue_head(&vcpu->arch.local_int.wq);
358 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
359 spin_unlock(&kvm->arch.float_int.lock);
361 rc = kvm_vcpu_init(vcpu, kvm, id);
362 if (rc)
363 goto out_free_sie_block;
364 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
365 vcpu->arch.sie_block);
367 return vcpu;
368 out_free_sie_block:
369 free_page((unsigned long)(vcpu->arch.sie_block));
370 out_free_cpu:
371 kfree(vcpu);
372 out:
373 return ERR_PTR(rc);
376 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
378 /* kvm common code refers to this, but never calls it */
379 BUG();
380 return 0;
383 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
385 kvm_s390_vcpu_initial_reset(vcpu);
386 return 0;
389 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
391 memcpy(&vcpu->arch.guest_gprs, &regs->gprs, sizeof(regs->gprs));
392 return 0;
395 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
397 memcpy(&regs->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs));
398 return 0;
401 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
402 struct kvm_sregs *sregs)
404 memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs));
405 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
406 restore_access_regs(vcpu->arch.guest_acrs);
407 return 0;
410 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
411 struct kvm_sregs *sregs)
413 memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs));
414 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
415 return 0;
418 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
420 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
421 vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK;
422 restore_fp_regs(&vcpu->arch.guest_fpregs);
423 return 0;
426 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
428 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
429 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
430 return 0;
433 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
435 int rc = 0;
437 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
438 rc = -EBUSY;
439 else {
440 vcpu->run->psw_mask = psw.mask;
441 vcpu->run->psw_addr = psw.addr;
443 return rc;
446 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
447 struct kvm_translation *tr)
449 return -EINVAL; /* not implemented yet */
452 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
453 struct kvm_guest_debug *dbg)
455 return -EINVAL; /* not implemented yet */
458 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
459 struct kvm_mp_state *mp_state)
461 return -EINVAL; /* not implemented yet */
464 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
465 struct kvm_mp_state *mp_state)
467 return -EINVAL; /* not implemented yet */
470 static void __vcpu_run(struct kvm_vcpu *vcpu)
472 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16);
474 if (need_resched())
475 schedule();
477 if (test_thread_flag(TIF_MCCK_PENDING))
478 s390_handle_mcck();
480 kvm_s390_deliver_pending_interrupts(vcpu);
482 vcpu->arch.sie_block->icptcode = 0;
483 local_irq_disable();
484 kvm_guest_enter();
485 local_irq_enable();
486 VCPU_EVENT(vcpu, 6, "entering sie flags %x",
487 atomic_read(&vcpu->arch.sie_block->cpuflags));
488 if (sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs)) {
489 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
490 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
492 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
493 vcpu->arch.sie_block->icptcode);
494 local_irq_disable();
495 kvm_guest_exit();
496 local_irq_enable();
498 memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16);
501 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
503 int rc;
504 sigset_t sigsaved;
506 rerun_vcpu:
507 if (vcpu->sigset_active)
508 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
510 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
512 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
514 switch (kvm_run->exit_reason) {
515 case KVM_EXIT_S390_SIEIC:
516 case KVM_EXIT_UNKNOWN:
517 case KVM_EXIT_INTR:
518 case KVM_EXIT_S390_RESET:
519 break;
520 default:
521 BUG();
524 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
525 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
527 might_fault();
529 do {
530 __vcpu_run(vcpu);
531 rc = kvm_handle_sie_intercept(vcpu);
532 } while (!signal_pending(current) && !rc);
534 if (rc == SIE_INTERCEPT_RERUNVCPU)
535 goto rerun_vcpu;
537 if (signal_pending(current) && !rc) {
538 kvm_run->exit_reason = KVM_EXIT_INTR;
539 rc = -EINTR;
542 if (rc == -EOPNOTSUPP) {
543 /* intercept cannot be handled in-kernel, prepare kvm-run */
544 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
545 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
546 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
547 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
548 rc = 0;
551 if (rc == -EREMOTE) {
552 /* intercept was handled, but userspace support is needed
553 * kvm_run has been prepared by the handler */
554 rc = 0;
557 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
558 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
560 if (vcpu->sigset_active)
561 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
563 vcpu->stat.exit_userspace++;
564 return rc;
567 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
568 unsigned long n, int prefix)
570 if (prefix)
571 return copy_to_guest(vcpu, guestdest, from, n);
572 else
573 return copy_to_guest_absolute(vcpu, guestdest, from, n);
577 * store status at address
578 * we use have two special cases:
579 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
580 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
582 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
584 unsigned char archmode = 1;
585 int prefix;
587 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
588 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
589 return -EFAULT;
590 addr = SAVE_AREA_BASE;
591 prefix = 0;
592 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
593 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
594 return -EFAULT;
595 addr = SAVE_AREA_BASE;
596 prefix = 1;
597 } else
598 prefix = 0;
600 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
601 vcpu->arch.guest_fpregs.fprs, 128, prefix))
602 return -EFAULT;
604 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
605 vcpu->arch.guest_gprs, 128, prefix))
606 return -EFAULT;
608 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
609 &vcpu->arch.sie_block->gpsw, 16, prefix))
610 return -EFAULT;
612 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
613 &vcpu->arch.sie_block->prefix, 4, prefix))
614 return -EFAULT;
616 if (__guestcopy(vcpu,
617 addr + offsetof(struct save_area, fp_ctrl_reg),
618 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
619 return -EFAULT;
621 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
622 &vcpu->arch.sie_block->todpr, 4, prefix))
623 return -EFAULT;
625 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
626 &vcpu->arch.sie_block->cputm, 8, prefix))
627 return -EFAULT;
629 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
630 &vcpu->arch.sie_block->ckc, 8, prefix))
631 return -EFAULT;
633 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
634 &vcpu->arch.guest_acrs, 64, prefix))
635 return -EFAULT;
637 if (__guestcopy(vcpu,
638 addr + offsetof(struct save_area, ctrl_regs),
639 &vcpu->arch.sie_block->gcr, 128, prefix))
640 return -EFAULT;
641 return 0;
644 long kvm_arch_vcpu_ioctl(struct file *filp,
645 unsigned int ioctl, unsigned long arg)
647 struct kvm_vcpu *vcpu = filp->private_data;
648 void __user *argp = (void __user *)arg;
649 long r;
651 switch (ioctl) {
652 case KVM_S390_INTERRUPT: {
653 struct kvm_s390_interrupt s390int;
655 r = -EFAULT;
656 if (copy_from_user(&s390int, argp, sizeof(s390int)))
657 break;
658 r = kvm_s390_inject_vcpu(vcpu, &s390int);
659 break;
661 case KVM_S390_STORE_STATUS:
662 r = kvm_s390_vcpu_store_status(vcpu, arg);
663 break;
664 case KVM_S390_SET_INITIAL_PSW: {
665 psw_t psw;
667 r = -EFAULT;
668 if (copy_from_user(&psw, argp, sizeof(psw)))
669 break;
670 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
671 break;
673 case KVM_S390_INITIAL_RESET:
674 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
675 break;
676 default:
677 r = -EINVAL;
679 return r;
682 /* Section: memory related */
683 int kvm_arch_prepare_memory_region(struct kvm *kvm,
684 struct kvm_memory_slot *memslot,
685 struct kvm_memory_slot old,
686 struct kvm_userspace_memory_region *mem,
687 int user_alloc)
689 /* A few sanity checks. We can have exactly one memory slot which has
690 to start at guest virtual zero and which has to be located at a
691 page boundary in userland and which has to end at a page boundary.
692 The memory in userland is ok to be fragmented into various different
693 vmas. It is okay to mmap() and munmap() stuff in this slot after
694 doing this call at any time */
696 if (mem->slot)
697 return -EINVAL;
699 if (mem->guest_phys_addr)
700 return -EINVAL;
702 if (mem->userspace_addr & 0xffffful)
703 return -EINVAL;
705 if (mem->memory_size & 0xffffful)
706 return -EINVAL;
708 if (!user_alloc)
709 return -EINVAL;
711 return 0;
714 void kvm_arch_commit_memory_region(struct kvm *kvm,
715 struct kvm_userspace_memory_region *mem,
716 struct kvm_memory_slot old,
717 int user_alloc)
719 int rc;
722 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
723 mem->guest_phys_addr, mem->memory_size);
724 if (rc)
725 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
726 return;
729 void kvm_arch_flush_shadow(struct kvm *kvm)
733 static int __init kvm_s390_init(void)
735 int ret;
736 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
737 if (ret)
738 return ret;
741 * guests can ask for up to 255+1 double words, we need a full page
742 * to hold the maximum amount of facilities. On the other hand, we
743 * only set facilities that are known to work in KVM.
745 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
746 if (!facilities) {
747 kvm_exit();
748 return -ENOMEM;
750 memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
751 facilities[0] &= 0xff00fff3f47c0000ULL;
752 facilities[1] &= 0x201c000000000000ULL;
753 return 0;
756 static void __exit kvm_s390_exit(void)
758 free_page((unsigned long) facilities);
759 kvm_exit();
762 module_init(kvm_s390_init);
763 module_exit(kvm_s390_exit);