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