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