[S390] remove kvm mmu reload on s390
[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         vcpu->arch.sie_block->ecb   = 6;
298         vcpu->arch.sie_block->eca   = 0xC1002001U;
299         vcpu->arch.sie_block->fac   = (int) (long) facilities;
300         hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
301         tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
302                      (unsigned long) vcpu);
303         vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
304         get_cpu_id(&vcpu->arch.cpu_id);
305         vcpu->arch.cpu_id.version = 0xff;
306         return 0;
307 }
308
309 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
310                                       unsigned int id)
311 {
312         struct kvm_vcpu *vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
313         int rc = -ENOMEM;
314
315         if (!vcpu)
316                 goto out_nomem;
317
318         vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
319                                         get_zeroed_page(GFP_KERNEL);
320
321         if (!vcpu->arch.sie_block)
322                 goto out_free_cpu;
323
324         vcpu->arch.sie_block->icpua = id;
325         BUG_ON(!kvm->arch.sca);
326         if (!kvm->arch.sca->cpu[id].sda)
327                 kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block;
328         vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32);
329         vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
330         set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
331
332         spin_lock_init(&vcpu->arch.local_int.lock);
333         INIT_LIST_HEAD(&vcpu->arch.local_int.list);
334         vcpu->arch.local_int.float_int = &kvm->arch.float_int;
335         spin_lock(&kvm->arch.float_int.lock);
336         kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
337         init_waitqueue_head(&vcpu->arch.local_int.wq);
338         vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
339         spin_unlock(&kvm->arch.float_int.lock);
340
341         rc = kvm_vcpu_init(vcpu, kvm, id);
342         if (rc)
343                 goto out_free_sie_block;
344         VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
345                  vcpu->arch.sie_block);
346
347         return vcpu;
348 out_free_sie_block:
349         free_page((unsigned long)(vcpu->arch.sie_block));
350 out_free_cpu:
351         kfree(vcpu);
352 out_nomem:
353         return ERR_PTR(rc);
354 }
355
356 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
357 {
358         /* kvm common code refers to this, but never calls it */
359         BUG();
360         return 0;
361 }
362
363 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
364 {
365         kvm_s390_vcpu_initial_reset(vcpu);
366         return 0;
367 }
368
369 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
370 {
371         memcpy(&vcpu->arch.guest_gprs, &regs->gprs, sizeof(regs->gprs));
372         return 0;
373 }
374
375 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
376 {
377         memcpy(&regs->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs));
378         return 0;
379 }
380
381 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
382                                   struct kvm_sregs *sregs)
383 {
384         memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs));
385         memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
386         return 0;
387 }
388
389 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
390                                   struct kvm_sregs *sregs)
391 {
392         memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs));
393         memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
394         return 0;
395 }
396
397 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
398 {
399         memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
400         vcpu->arch.guest_fpregs.fpc = fpu->fpc;
401         return 0;
402 }
403
404 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
405 {
406         memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
407         fpu->fpc = vcpu->arch.guest_fpregs.fpc;
408         return 0;
409 }
410
411 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
412 {
413         int rc = 0;
414
415         if (atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_RUNNING)
416                 rc = -EBUSY;
417         else {
418                 vcpu->run->psw_mask = psw.mask;
419                 vcpu->run->psw_addr = psw.addr;
420         }
421         return rc;
422 }
423
424 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
425                                   struct kvm_translation *tr)
426 {
427         return -EINVAL; /* not implemented yet */
428 }
429
430 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
431                                         struct kvm_guest_debug *dbg)
432 {
433         return -EINVAL; /* not implemented yet */
434 }
435
436 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
437                                     struct kvm_mp_state *mp_state)
438 {
439         return -EINVAL; /* not implemented yet */
440 }
441
442 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
443                                     struct kvm_mp_state *mp_state)
444 {
445         return -EINVAL; /* not implemented yet */
446 }
447
448 static void __vcpu_run(struct kvm_vcpu *vcpu)
449 {
450         memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16);
451
452         if (need_resched())
453                 schedule();
454
455         if (test_thread_flag(TIF_MCCK_PENDING))
456                 s390_handle_mcck();
457
458         kvm_s390_deliver_pending_interrupts(vcpu);
459
460         vcpu->arch.sie_block->icptcode = 0;
461         local_irq_disable();
462         kvm_guest_enter();
463         local_irq_enable();
464         gmap_enable(vcpu->arch.gmap);
465         VCPU_EVENT(vcpu, 6, "entering sie flags %x",
466                    atomic_read(&vcpu->arch.sie_block->cpuflags));
467         if (sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs)) {
468                 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
469                 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
470         }
471         VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
472                    vcpu->arch.sie_block->icptcode);
473         gmap_disable(vcpu->arch.gmap);
474         local_irq_disable();
475         kvm_guest_exit();
476         local_irq_enable();
477
478         memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16);
479 }
480
481 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
482 {
483         int rc;
484         sigset_t sigsaved;
485
486 rerun_vcpu:
487         if (vcpu->sigset_active)
488                 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
489
490         atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
491
492         BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
493
494         switch (kvm_run->exit_reason) {
495         case KVM_EXIT_S390_SIEIC:
496         case KVM_EXIT_UNKNOWN:
497         case KVM_EXIT_INTR:
498         case KVM_EXIT_S390_RESET:
499                 break;
500         default:
501                 BUG();
502         }
503
504         vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
505         vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
506
507         might_fault();
508
509         do {
510                 __vcpu_run(vcpu);
511                 rc = kvm_handle_sie_intercept(vcpu);
512         } while (!signal_pending(current) && !rc);
513
514         if (rc == SIE_INTERCEPT_RERUNVCPU)
515                 goto rerun_vcpu;
516
517         if (signal_pending(current) && !rc) {
518                 kvm_run->exit_reason = KVM_EXIT_INTR;
519                 rc = -EINTR;
520         }
521
522         if (rc == -EOPNOTSUPP) {
523                 /* intercept cannot be handled in-kernel, prepare kvm-run */
524                 kvm_run->exit_reason         = KVM_EXIT_S390_SIEIC;
525                 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
526                 kvm_run->s390_sieic.ipa      = vcpu->arch.sie_block->ipa;
527                 kvm_run->s390_sieic.ipb      = vcpu->arch.sie_block->ipb;
528                 rc = 0;
529         }
530
531         if (rc == -EREMOTE) {
532                 /* intercept was handled, but userspace support is needed
533                  * kvm_run has been prepared by the handler */
534                 rc = 0;
535         }
536
537         kvm_run->psw_mask     = vcpu->arch.sie_block->gpsw.mask;
538         kvm_run->psw_addr     = vcpu->arch.sie_block->gpsw.addr;
539
540         if (vcpu->sigset_active)
541                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
542
543         vcpu->stat.exit_userspace++;
544         return rc;
545 }
546
547 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
548                        unsigned long n, int prefix)
549 {
550         if (prefix)
551                 return copy_to_guest(vcpu, guestdest, from, n);
552         else
553                 return copy_to_guest_absolute(vcpu, guestdest, from, n);
554 }
555
556 /*
557  * store status at address
558  * we use have two special cases:
559  * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
560  * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
561  */
562 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
563 {
564         unsigned char archmode = 1;
565         int prefix;
566
567         if (addr == KVM_S390_STORE_STATUS_NOADDR) {
568                 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
569                         return -EFAULT;
570                 addr = SAVE_AREA_BASE;
571                 prefix = 0;
572         } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
573                 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
574                         return -EFAULT;
575                 addr = SAVE_AREA_BASE;
576                 prefix = 1;
577         } else
578                 prefix = 0;
579
580         if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
581                         vcpu->arch.guest_fpregs.fprs, 128, prefix))
582                 return -EFAULT;
583
584         if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
585                         vcpu->arch.guest_gprs, 128, prefix))
586                 return -EFAULT;
587
588         if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
589                         &vcpu->arch.sie_block->gpsw, 16, prefix))
590                 return -EFAULT;
591
592         if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
593                         &vcpu->arch.sie_block->prefix, 4, prefix))
594                 return -EFAULT;
595
596         if (__guestcopy(vcpu,
597                         addr + offsetof(struct save_area, fp_ctrl_reg),
598                         &vcpu->arch.guest_fpregs.fpc, 4, prefix))
599                 return -EFAULT;
600
601         if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
602                         &vcpu->arch.sie_block->todpr, 4, prefix))
603                 return -EFAULT;
604
605         if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
606                         &vcpu->arch.sie_block->cputm, 8, prefix))
607                 return -EFAULT;
608
609         if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
610                         &vcpu->arch.sie_block->ckc, 8, prefix))
611                 return -EFAULT;
612
613         if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
614                         &vcpu->arch.guest_acrs, 64, prefix))
615                 return -EFAULT;
616
617         if (__guestcopy(vcpu,
618                         addr + offsetof(struct save_area, ctrl_regs),
619                         &vcpu->arch.sie_block->gcr, 128, prefix))
620                 return -EFAULT;
621         return 0;
622 }
623
624 long kvm_arch_vcpu_ioctl(struct file *filp,
625                          unsigned int ioctl, unsigned long arg)
626 {
627         struct kvm_vcpu *vcpu = filp->private_data;
628         void __user *argp = (void __user *)arg;
629         long r;
630
631         switch (ioctl) {
632         case KVM_S390_INTERRUPT: {
633                 struct kvm_s390_interrupt s390int;
634
635                 r = -EFAULT;
636                 if (copy_from_user(&s390int, argp, sizeof(s390int)))
637                         break;
638                 r = kvm_s390_inject_vcpu(vcpu, &s390int);
639                 break;
640         }
641         case KVM_S390_STORE_STATUS:
642                 r = kvm_s390_vcpu_store_status(vcpu, arg);
643                 break;
644         case KVM_S390_SET_INITIAL_PSW: {
645                 psw_t psw;
646
647                 r = -EFAULT;
648                 if (copy_from_user(&psw, argp, sizeof(psw)))
649                         break;
650                 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
651                 break;
652         }
653         case KVM_S390_INITIAL_RESET:
654                 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
655                 break;
656         default:
657                 r = -EINVAL;
658         }
659         return r;
660 }
661
662 /* Section: memory related */
663 int kvm_arch_prepare_memory_region(struct kvm *kvm,
664                                    struct kvm_memory_slot *memslot,
665                                    struct kvm_memory_slot old,
666                                    struct kvm_userspace_memory_region *mem,
667                                    int user_alloc)
668 {
669         /* A few sanity checks. We can have exactly one memory slot which has
670            to start at guest virtual zero and which has to be located at a
671            page boundary in userland and which has to end at a page boundary.
672            The memory in userland is ok to be fragmented into various different
673            vmas. It is okay to mmap() and munmap() stuff in this slot after
674            doing this call at any time */
675
676         if (mem->slot)
677                 return -EINVAL;
678
679         if (mem->guest_phys_addr)
680                 return -EINVAL;
681
682         if (mem->userspace_addr & 0xffffful)
683                 return -EINVAL;
684
685         if (mem->memory_size & 0xffffful)
686                 return -EINVAL;
687
688         if (!user_alloc)
689                 return -EINVAL;
690
691         return 0;
692 }
693
694 void kvm_arch_commit_memory_region(struct kvm *kvm,
695                                 struct kvm_userspace_memory_region *mem,
696                                 struct kvm_memory_slot old,
697                                 int user_alloc)
698 {
699         int rc;
700
701
702         rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
703                 mem->guest_phys_addr, mem->memory_size);
704         if (rc)
705                 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
706         return;
707 }
708
709 void kvm_arch_flush_shadow(struct kvm *kvm)
710 {
711 }
712
713 static int __init kvm_s390_init(void)
714 {
715         int ret;
716         ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
717         if (ret)
718                 return ret;
719
720         /*
721          * guests can ask for up to 255+1 double words, we need a full page
722          * to hold the maximum amount of facilities. On the other hand, we
723          * only set facilities that are known to work in KVM.
724          */
725         facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
726         if (!facilities) {
727                 kvm_exit();
728                 return -ENOMEM;
729         }
730         memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
731         facilities[0] &= 0xff00fff3f47c0000ULL;
732         facilities[1] &= 0x201c000000000000ULL;
733         return 0;
734 }
735
736 static void __exit kvm_s390_exit(void)
737 {
738         free_page((unsigned long) facilities);
739         kvm_exit();
740 }
741
742 module_init(kvm_s390_init);
743 module_exit(kvm_s390_exit);