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