?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tools: Add missing files to build the python binding
[linux-2.6/btrfs-unstable.git] / arch / s390 / kvm / kvm-s390.c
blobd470ccbfabae02e015e206f833a93ec0820941fa
1 /*
2 * 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/switch_to.h>
31 #include <asm/sclp.h>
32 #include "kvm-s390.h"
33 #include "gaccess.h"
34
35 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
36
37 struct kvm_stats_debugfs_item debugfs_entries[] = {
38 { "userspace_handled", VCPU_STAT(exit_userspace) },
39 { "exit_null", VCPU_STAT(exit_null) },
40 { "exit_validity", VCPU_STAT(exit_validity) },
41 { "exit_stop_request", VCPU_STAT(exit_stop_request) },
42 { "exit_external_request", VCPU_STAT(exit_external_request) },
43 { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
44 { "exit_instruction", VCPU_STAT(exit_instruction) },
45 { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
46 { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
47 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
48 { "instruction_lctl", VCPU_STAT(instruction_lctl) },
49 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
50 { "deliver_external_call", VCPU_STAT(deliver_external_call) },
51 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
52 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
53 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
54 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
55 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
56 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
57 { "exit_wait_state", VCPU_STAT(exit_wait_state) },
58 { "instruction_stidp", VCPU_STAT(instruction_stidp) },
59 { "instruction_spx", VCPU_STAT(instruction_spx) },
60 { "instruction_stpx", VCPU_STAT(instruction_stpx) },
61 { "instruction_stap", VCPU_STAT(instruction_stap) },
62 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
63 { "instruction_stsch", VCPU_STAT(instruction_stsch) },
64 { "instruction_chsc", VCPU_STAT(instruction_chsc) },
65 { "instruction_stsi", VCPU_STAT(instruction_stsi) },
66 { "instruction_stfl", VCPU_STAT(instruction_stfl) },
67 { "instruction_tprot", VCPU_STAT(instruction_tprot) },
68 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
69 { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
70 { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
71 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
72 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
73 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
74 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
75 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
76 { "diagnose_10", VCPU_STAT(diagnose_10) },
77 { "diagnose_44", VCPU_STAT(diagnose_44) },
78 { "diagnose_9c", VCPU_STAT(diagnose_9c) },
79 { NULL }
80 };
81
82 static unsigned long long *facilities;
83
84 /* Section: not file related */
85 int kvm_arch_hardware_enable(void *garbage)
86 {
87 /* every s390 is virtualization enabled ;-) */
88 return 0;
89 }
90
91 void kvm_arch_hardware_disable(void *garbage)
92 {
93 }
94
95 int kvm_arch_hardware_setup(void)
96 {
97 return 0;
98 }
99
100 void kvm_arch_hardware_unsetup(void)
101 {
102 }
103
104 void kvm_arch_check_processor_compat(void *rtn)
105 {
106 }
107
108 int kvm_arch_init(void *opaque)
109 {
110 return 0;
111 }
112
113 void kvm_arch_exit(void)
114 {
115 }
116
117 /* Section: device related */
118 long kvm_arch_dev_ioctl(struct file *filp,
119 unsigned int ioctl, unsigned long arg)
120 {
121 if (ioctl == KVM_S390_ENABLE_SIE)
122 return s390_enable_sie();
123 return -EINVAL;
124 }
125
126 int kvm_dev_ioctl_check_extension(long ext)
127 {
128 int r;
129
130 switch (ext) {
131 case KVM_CAP_S390_PSW:
132 case KVM_CAP_S390_GMAP:
133 case KVM_CAP_SYNC_MMU:
134 #ifdef CONFIG_KVM_S390_UCONTROL
135 case KVM_CAP_S390_UCONTROL:
136 #endif
137 case KVM_CAP_SYNC_REGS:
138 case KVM_CAP_ONE_REG:
139 r = 1;
140 break;
141 case KVM_CAP_NR_VCPUS:
142 case KVM_CAP_MAX_VCPUS:
143 r = KVM_MAX_VCPUS;
144 break;
145 case KVM_CAP_S390_COW:
146 r = sclp_get_fac85() & 0x2;
147 break;
148 default:
149 r = 0;
150 }
151 return r;
152 }
153
154 /* Section: vm related */
155 /*
156 * Get (and clear) the dirty memory log for a memory slot.
157 */
158 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
159 struct kvm_dirty_log *log)
160 {
161 return 0;
162 }
163
164 long kvm_arch_vm_ioctl(struct file *filp,
165 unsigned int ioctl, unsigned long arg)
166 {
167 struct kvm *kvm = filp->private_data;
168 void __user *argp = (void __user *)arg;
169 int r;
170
171 switch (ioctl) {
172 case KVM_S390_INTERRUPT: {
173 struct kvm_s390_interrupt s390int;
174
175 r = -EFAULT;
176 if (copy_from_user(&s390int, argp, sizeof(s390int)))
177 break;
178 r = kvm_s390_inject_vm(kvm, &s390int);
179 break;
180 }
181 default:
182 r = -ENOTTY;
183 }
184
185 return r;
186 }
187
188 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
189 {
190 int rc;
191 char debug_name[16];
192
193 rc = -EINVAL;
194 #ifdef CONFIG_KVM_S390_UCONTROL
195 if (type & ~KVM_VM_S390_UCONTROL)
196 goto out_err;
197 if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
198 goto out_err;
199 #else
200 if (type)
201 goto out_err;
202 #endif
203
204 rc = s390_enable_sie();
205 if (rc)
206 goto out_err;
207
208 rc = -ENOMEM;
209
210 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
211 if (!kvm->arch.sca)
212 goto out_err;
213
214 sprintf(debug_name, "kvm-%u", current->pid);
215
216 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
217 if (!kvm->arch.dbf)
218 goto out_nodbf;
219
220 spin_lock_init(&kvm->arch.float_int.lock);
221 INIT_LIST_HEAD(&kvm->arch.float_int.list);
222
223 debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
224 VM_EVENT(kvm, 3, "%s", "vm created");
225
226 if (type & KVM_VM_S390_UCONTROL) {
227 kvm->arch.gmap = NULL;
228 } else {
229 kvm->arch.gmap = gmap_alloc(current->mm);
230 if (!kvm->arch.gmap)
231 goto out_nogmap;
232 }
233 return 0;
234 out_nogmap:
235 debug_unregister(kvm->arch.dbf);
236 out_nodbf:
237 free_page((unsigned long)(kvm->arch.sca));
238 out_err:
239 return rc;
240 }
241
242 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
243 {
244 VCPU_EVENT(vcpu, 3, "%s", "free cpu");
245 if (!kvm_is_ucontrol(vcpu->kvm)) {
246 clear_bit(63 - vcpu->vcpu_id,
247 (unsigned long *) &vcpu->kvm->arch.sca->mcn);
248 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
249 (__u64) vcpu->arch.sie_block)
250 vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
251 }
252 smp_mb();
253
254 if (kvm_is_ucontrol(vcpu->kvm))
255 gmap_free(vcpu->arch.gmap);
256
257 free_page((unsigned long)(vcpu->arch.sie_block));
258 kvm_vcpu_uninit(vcpu);
259 kfree(vcpu);
260 }
261
262 static void kvm_free_vcpus(struct kvm *kvm)
263 {
264 unsigned int i;
265 struct kvm_vcpu *vcpu;
266
267 kvm_for_each_vcpu(i, vcpu, kvm)
268 kvm_arch_vcpu_destroy(vcpu);
269
270 mutex_lock(&kvm->lock);
271 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
272 kvm->vcpus[i] = NULL;
273
274 atomic_set(&kvm->online_vcpus, 0);
275 mutex_unlock(&kvm->lock);
276 }
277
278 void kvm_arch_sync_events(struct kvm *kvm)
279 {
280 }
281
282 void kvm_arch_destroy_vm(struct kvm *kvm)
283 {
284 kvm_free_vcpus(kvm);
285 free_page((unsigned long)(kvm->arch.sca));
286 debug_unregister(kvm->arch.dbf);
287 if (!kvm_is_ucontrol(kvm))
288 gmap_free(kvm->arch.gmap);
289 }
290
291 /* Section: vcpu related */
292 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
293 {
294 if (kvm_is_ucontrol(vcpu->kvm)) {
295 vcpu->arch.gmap = gmap_alloc(current->mm);
296 if (!vcpu->arch.gmap)
297 return -ENOMEM;
298 return 0;
299 }
300
301 vcpu->arch.gmap = vcpu->kvm->arch.gmap;
302 vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
303 KVM_SYNC_GPRS |
304 KVM_SYNC_ACRS |
305 KVM_SYNC_CRS;
306 return 0;
307 }
308
309 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
310 {
311 /* Nothing todo */
312 }
313
314 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
315 {
316 save_fp_regs(&vcpu->arch.host_fpregs);
317 save_access_regs(vcpu->arch.host_acrs);
318 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
319 restore_fp_regs(&vcpu->arch.guest_fpregs);
320 restore_access_regs(vcpu->run->s.regs.acrs);
321 gmap_enable(vcpu->arch.gmap);
322 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
323 }
324
325 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
326 {
327 atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
328 gmap_disable(vcpu->arch.gmap);
329 save_fp_regs(&vcpu->arch.guest_fpregs);
330 save_access_regs(vcpu->run->s.regs.acrs);
331 restore_fp_regs(&vcpu->arch.host_fpregs);
332 restore_access_regs(vcpu->arch.host_acrs);
333 }
334
335 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
336 {
337 /* this equals initial cpu reset in pop, but we don't switch to ESA */
338 vcpu->arch.sie_block->gpsw.mask = 0UL;
339 vcpu->arch.sie_block->gpsw.addr = 0UL;
340 kvm_s390_set_prefix(vcpu, 0);
341 vcpu->arch.sie_block->cputm = 0UL;
342 vcpu->arch.sie_block->ckc = 0UL;
343 vcpu->arch.sie_block->todpr = 0;
344 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
345 vcpu->arch.sie_block->gcr[0] = 0xE0UL;
346 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
347 vcpu->arch.guest_fpregs.fpc = 0;
348 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
349 vcpu->arch.sie_block->gbea = 1;
350 atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
351 }
352
353 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
354 {
355 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
356 CPUSTAT_SM |
357 CPUSTAT_STOPPED);
358 vcpu->arch.sie_block->ecb = 6;
359 vcpu->arch.sie_block->eca = 0xC1002001U;
360 vcpu->arch.sie_block->fac = (int) (long) facilities;
361 hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
362 tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
363 (unsigned long) vcpu);
364 vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
365 get_cpu_id(&vcpu->arch.cpu_id);
366 vcpu->arch.cpu_id.version = 0xff;
367 return 0;
368 }
369
370 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
371 unsigned int id)
372 {
373 struct kvm_vcpu *vcpu;
374 int rc = -EINVAL;
375
376 if (id >= KVM_MAX_VCPUS)
377 goto out;
378
379 rc = -ENOMEM;
380
381 vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
382 if (!vcpu)
383 goto out;
384
385 vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
386 get_zeroed_page(GFP_KERNEL);
387
388 if (!vcpu->arch.sie_block)
389 goto out_free_cpu;
390
391 vcpu->arch.sie_block->icpua = id;
392 if (!kvm_is_ucontrol(kvm)) {
393 if (!kvm->arch.sca) {
394 WARN_ON_ONCE(1);
395 goto out_free_cpu;
396 }
397 if (!kvm->arch.sca->cpu[id].sda)
398 kvm->arch.sca->cpu[id].sda =
399 (__u64) vcpu->arch.sie_block;
400 vcpu->arch.sie_block->scaoh =
401 (__u32)(((__u64)kvm->arch.sca) >> 32);
402 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
403 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
404 }
405
406 spin_lock_init(&vcpu->arch.local_int.lock);
407 INIT_LIST_HEAD(&vcpu->arch.local_int.list);
408 vcpu->arch.local_int.float_int = &kvm->arch.float_int;
409 spin_lock(&kvm->arch.float_int.lock);
410 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
411 init_waitqueue_head(&vcpu->arch.local_int.wq);
412 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
413 spin_unlock(&kvm->arch.float_int.lock);
414
415 rc = kvm_vcpu_init(vcpu, kvm, id);
416 if (rc)
417 goto out_free_sie_block;
418 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
419 vcpu->arch.sie_block);
420
421 return vcpu;
422 out_free_sie_block:
423 free_page((unsigned long)(vcpu->arch.sie_block));
424 out_free_cpu:
425 kfree(vcpu);
426 out:
427 return ERR_PTR(rc);
428 }
429
430 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
431 {
432 /* kvm common code refers to this, but never calls it */
433 BUG();
434 return 0;
435 }
436
437 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
438 {
439 /* kvm common code refers to this, but never calls it */
440 BUG();
441 return 0;
442 }
443
444 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
445 struct kvm_one_reg *reg)
446 {
447 int r = -EINVAL;
448
449 switch (reg->id) {
450 case KVM_REG_S390_TODPR:
451 r = put_user(vcpu->arch.sie_block->todpr,
452 (u32 __user *)reg->addr);
453 break;
454 case KVM_REG_S390_EPOCHDIFF:
455 r = put_user(vcpu->arch.sie_block->epoch,
456 (u64 __user *)reg->addr);
457 break;
458 case KVM_REG_S390_CPU_TIMER:
459 r = put_user(vcpu->arch.sie_block->cputm,
460 (u64 __user *)reg->addr);
461 break;
462 case KVM_REG_S390_CLOCK_COMP:
463 r = put_user(vcpu->arch.sie_block->ckc,
464 (u64 __user *)reg->addr);
465 break;
466 default:
467 break;
468 }
469
470 return r;
471 }
472
473 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
474 struct kvm_one_reg *reg)
475 {
476 int r = -EINVAL;
477
478 switch (reg->id) {
479 case KVM_REG_S390_TODPR:
480 r = get_user(vcpu->arch.sie_block->todpr,
481 (u32 __user *)reg->addr);
482 break;
483 case KVM_REG_S390_EPOCHDIFF:
484 r = get_user(vcpu->arch.sie_block->epoch,
485 (u64 __user *)reg->addr);
486 break;
487 case KVM_REG_S390_CPU_TIMER:
488 r = get_user(vcpu->arch.sie_block->cputm,
489 (u64 __user *)reg->addr);
490 break;
491 case KVM_REG_S390_CLOCK_COMP:
492 r = get_user(vcpu->arch.sie_block->ckc,
493 (u64 __user *)reg->addr);
494 break;
495 default:
496 break;
497 }
498
499 return r;
500 }
501
502 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
503 {
504 kvm_s390_vcpu_initial_reset(vcpu);
505 return 0;
506 }
507
508 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
509 {
510 memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
511 return 0;
512 }
513
514 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
515 {
516 memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
517 return 0;
518 }
519
520 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
521 struct kvm_sregs *sregs)
522 {
523 memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
524 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
525 restore_access_regs(vcpu->run->s.regs.acrs);
526 return 0;
527 }
528
529 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
530 struct kvm_sregs *sregs)
531 {
532 memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
533 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
534 return 0;
535 }
536
537 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
538 {
539 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
540 vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK;
541 restore_fp_regs(&vcpu->arch.guest_fpregs);
542 return 0;
543 }
544
545 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
546 {
547 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
548 fpu->fpc = vcpu->arch.guest_fpregs.fpc;
549 return 0;
550 }
551
552 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
553 {
554 int rc = 0;
555
556 if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
557 rc = -EBUSY;
558 else {
559 vcpu->run->psw_mask = psw.mask;
560 vcpu->run->psw_addr = psw.addr;
561 }
562 return rc;
563 }
564
565 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
566 struct kvm_translation *tr)
567 {
568 return -EINVAL; /* not implemented yet */
569 }
570
571 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
572 struct kvm_guest_debug *dbg)
573 {
574 return -EINVAL; /* not implemented yet */
575 }
576
577 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
578 struct kvm_mp_state *mp_state)
579 {
580 return -EINVAL; /* not implemented yet */
581 }
582
583 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
584 struct kvm_mp_state *mp_state)
585 {
586 return -EINVAL; /* not implemented yet */
587 }
588
589 static int __vcpu_run(struct kvm_vcpu *vcpu)
590 {
591 int rc;
592
593 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
594
595 if (need_resched())
596 schedule();
597
598 if (test_thread_flag(TIF_MCCK_PENDING))
599 s390_handle_mcck();
600
601 if (!kvm_is_ucontrol(vcpu->kvm))
602 kvm_s390_deliver_pending_interrupts(vcpu);
603
604 vcpu->arch.sie_block->icptcode = 0;
605 local_irq_disable();
606 kvm_guest_enter();
607 local_irq_enable();
608 VCPU_EVENT(vcpu, 6, "entering sie flags %x",
609 atomic_read(&vcpu->arch.sie_block->cpuflags));
610 rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
611 if (rc) {
612 if (kvm_is_ucontrol(vcpu->kvm)) {
613 rc = SIE_INTERCEPT_UCONTROL;
614 } else {
615 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
616 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
617 rc = 0;
618 }
619 }
620 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
621 vcpu->arch.sie_block->icptcode);
622 local_irq_disable();
623 kvm_guest_exit();
624 local_irq_enable();
625
626 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
627 return rc;
628 }
629
630 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
631 {
632 int rc;
633 sigset_t sigsaved;
634
635 rerun_vcpu:
636 if (vcpu->sigset_active)
637 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
638
639 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
640
641 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
642
643 switch (kvm_run->exit_reason) {
644 case KVM_EXIT_S390_SIEIC:
645 case KVM_EXIT_UNKNOWN:
646 case KVM_EXIT_INTR:
647 case KVM_EXIT_S390_RESET:
648 case KVM_EXIT_S390_UCONTROL:
649 break;
650 default:
651 BUG();
652 }
653
654 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
655 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
656 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
657 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
658 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
659 }
660 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
661 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
662 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
663 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
664 }
665
666 might_fault();
667
668 do {
669 rc = __vcpu_run(vcpu);
670 if (rc)
671 break;
672 if (kvm_is_ucontrol(vcpu->kvm))
673 rc = -EOPNOTSUPP;
674 else
675 rc = kvm_handle_sie_intercept(vcpu);
676 } while (!signal_pending(current) && !rc);
677
678 if (rc == SIE_INTERCEPT_RERUNVCPU)
679 goto rerun_vcpu;
680
681 if (signal_pending(current) && !rc) {
682 kvm_run->exit_reason = KVM_EXIT_INTR;
683 rc = -EINTR;
684 }
685
686 #ifdef CONFIG_KVM_S390_UCONTROL
687 if (rc == SIE_INTERCEPT_UCONTROL) {
688 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
689 kvm_run->s390_ucontrol.trans_exc_code =
690 current->thread.gmap_addr;
691 kvm_run->s390_ucontrol.pgm_code = 0x10;
692 rc = 0;
693 }
694 #endif
695
696 if (rc == -EOPNOTSUPP) {
697 /* intercept cannot be handled in-kernel, prepare kvm-run */
698 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
699 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
700 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
701 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
702 rc = 0;
703 }
704
705 if (rc == -EREMOTE) {
706 /* intercept was handled, but userspace support is needed
707 * kvm_run has been prepared by the handler */
708 rc = 0;
709 }
710
711 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
712 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
713 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
714 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
715
716 if (vcpu->sigset_active)
717 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
718
719 vcpu->stat.exit_userspace++;
720 return rc;
721 }
722
723 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
724 unsigned long n, int prefix)
725 {
726 if (prefix)
727 return copy_to_guest(vcpu, guestdest, from, n);
728 else
729 return copy_to_guest_absolute(vcpu, guestdest, from, n);
730 }
731
732 /*
733 * store status at address
734 * we use have two special cases:
735 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
736 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
737 */
738 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
739 {
740 unsigned char archmode = 1;
741 int prefix;
742
743 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
744 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
745 return -EFAULT;
746 addr = SAVE_AREA_BASE;
747 prefix = 0;
748 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
749 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
750 return -EFAULT;
751 addr = SAVE_AREA_BASE;
752 prefix = 1;
753 } else
754 prefix = 0;
755
756 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
757 vcpu->arch.guest_fpregs.fprs, 128, prefix))
758 return -EFAULT;
759
760 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
761 vcpu->run->s.regs.gprs, 128, prefix))
762 return -EFAULT;
763
764 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
765 &vcpu->arch.sie_block->gpsw, 16, prefix))
766 return -EFAULT;
767
768 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
769 &vcpu->arch.sie_block->prefix, 4, prefix))
770 return -EFAULT;
771
772 if (__guestcopy(vcpu,
773 addr + offsetof(struct save_area, fp_ctrl_reg),
774 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
775 return -EFAULT;
776
777 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
778 &vcpu->arch.sie_block->todpr, 4, prefix))
779 return -EFAULT;
780
781 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
782 &vcpu->arch.sie_block->cputm, 8, prefix))
783 return -EFAULT;
784
785 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
786 &vcpu->arch.sie_block->ckc, 8, prefix))
787 return -EFAULT;
788
789 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
790 &vcpu->run->s.regs.acrs, 64, prefix))
791 return -EFAULT;
792
793 if (__guestcopy(vcpu,
794 addr + offsetof(struct save_area, ctrl_regs),
795 &vcpu->arch.sie_block->gcr, 128, prefix))
796 return -EFAULT;
797 return 0;
798 }
799
800 long kvm_arch_vcpu_ioctl(struct file *filp,
801 unsigned int ioctl, unsigned long arg)
802 {
803 struct kvm_vcpu *vcpu = filp->private_data;
804 void __user *argp = (void __user *)arg;
805 long r;
806
807 switch (ioctl) {
808 case KVM_S390_INTERRUPT: {
809 struct kvm_s390_interrupt s390int;
810
811 r = -EFAULT;
812 if (copy_from_user(&s390int, argp, sizeof(s390int)))
813 break;
814 r = kvm_s390_inject_vcpu(vcpu, &s390int);
815 break;
816 }
817 case KVM_S390_STORE_STATUS:
818 r = kvm_s390_vcpu_store_status(vcpu, arg);
819 break;
820 case KVM_S390_SET_INITIAL_PSW: {
821 psw_t psw;
822
823 r = -EFAULT;
824 if (copy_from_user(&psw, argp, sizeof(psw)))
825 break;
826 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
827 break;
828 }
829 case KVM_S390_INITIAL_RESET:
830 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
831 break;
832 case KVM_SET_ONE_REG:
833 case KVM_GET_ONE_REG: {
834 struct kvm_one_reg reg;
835 r = -EFAULT;
836 if (copy_from_user(&reg, argp, sizeof(reg)))
837 break;
838 if (ioctl == KVM_SET_ONE_REG)
839 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
840 else
841 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
842 break;
843 }
844 #ifdef CONFIG_KVM_S390_UCONTROL
845 case KVM_S390_UCAS_MAP: {
846 struct kvm_s390_ucas_mapping ucasmap;
847
848 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
849 r = -EFAULT;
850 break;
851 }
852
853 if (!kvm_is_ucontrol(vcpu->kvm)) {
854 r = -EINVAL;
855 break;
856 }
857
858 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
859 ucasmap.vcpu_addr, ucasmap.length);
860 break;
861 }
862 case KVM_S390_UCAS_UNMAP: {
863 struct kvm_s390_ucas_mapping ucasmap;
864
865 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
866 r = -EFAULT;
867 break;
868 }
869
870 if (!kvm_is_ucontrol(vcpu->kvm)) {
871 r = -EINVAL;
872 break;
873 }
874
875 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
876 ucasmap.length);
877 break;
878 }
879 #endif
880 case KVM_S390_VCPU_FAULT: {
881 r = gmap_fault(arg, vcpu->arch.gmap);
882 if (!IS_ERR_VALUE(r))
883 r = 0;
884 break;
885 }
886 default:
887 r = -ENOTTY;
888 }
889 return r;
890 }
891
892 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
893 {
894 #ifdef CONFIG_KVM_S390_UCONTROL
895 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
896 && (kvm_is_ucontrol(vcpu->kvm))) {
897 vmf->page = virt_to_page(vcpu->arch.sie_block);
898 get_page(vmf->page);
899 return 0;
900 }
901 #endif
902 return VM_FAULT_SIGBUS;
903 }
904
905 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
906 struct kvm_memory_slot *dont)
907 {
908 }
909
910 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
911 {
912 return 0;
913 }
914
915 /* Section: memory related */
916 int kvm_arch_prepare_memory_region(struct kvm *kvm,
917 struct kvm_memory_slot *memslot,
918 struct kvm_memory_slot old,
919 struct kvm_userspace_memory_region *mem,
920 int user_alloc)
921 {
922 /* A few sanity checks. We can have exactly one memory slot which has
923 to start at guest virtual zero and which has to be located at a
924 page boundary in userland and which has to end at a page boundary.
925 The memory in userland is ok to be fragmented into various different
926 vmas. It is okay to mmap() and munmap() stuff in this slot after
927 doing this call at any time */
928
929 if (mem->slot)
930 return -EINVAL;
931
932 if (mem->guest_phys_addr)
933 return -EINVAL;
934
935 if (mem->userspace_addr & 0xffffful)
936 return -EINVAL;
937
938 if (mem->memory_size & 0xffffful)
939 return -EINVAL;
940
941 if (!user_alloc)
942 return -EINVAL;
943
944 return 0;
945 }
946
947 void kvm_arch_commit_memory_region(struct kvm *kvm,
948 struct kvm_userspace_memory_region *mem,
949 struct kvm_memory_slot old,
950 int user_alloc)
951 {
952 int rc;
953
954
955 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
956 mem->guest_phys_addr, mem->memory_size);
957 if (rc)
958 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
959 return;
960 }
961
962 void kvm_arch_flush_shadow(struct kvm *kvm)
963 {
964 }
965
966 static int __init kvm_s390_init(void)
967 {
968 int ret;
969 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
970 if (ret)
971 return ret;
972
973 /*
974 * guests can ask for up to 255+1 double words, we need a full page
975 * to hold the maximum amount of facilities. On the other hand, we
976 * only set facilities that are known to work in KVM.
977 */
978 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
979 if (!facilities) {
980 kvm_exit();
981 return -ENOMEM;
982 }
983 memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
984 facilities[0] &= 0xff00fff3f47c0000ULL;
985 facilities[1] &= 0x201c000000000000ULL;
986 return 0;
987 }
988
989 static void __exit kvm_s390_exit(void)
990 {
991 free_page((unsigned long) facilities);
992 kvm_exit();
993 }
994
995 module_init(kvm_s390_init);
996 module_exit(kvm_s390_exit);
(deprecated) Btrfs devel tree