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