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