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