projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-next' of git://github.com/rydberg/linux into next
[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_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 preempt_disable();
626 kvm_guest_enter();
627 preempt_enable();
628 VCPU_EVENT(vcpu, 6, "entering sie flags %x",
629 atomic_read(&vcpu->arch.sie_block->cpuflags));
630 trace_kvm_s390_sie_enter(vcpu,
631 atomic_read(&vcpu->arch.sie_block->cpuflags));
632 rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
633 if (rc) {
634 if (kvm_is_ucontrol(vcpu->kvm)) {
635 rc = SIE_INTERCEPT_UCONTROL;
636 } else {
637 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
638 trace_kvm_s390_sie_fault(vcpu);
639 rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
640 }
641 }
642 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
643 vcpu->arch.sie_block->icptcode);
644 trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
645 kvm_guest_exit();
646
647 memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
648 return rc;
649 }
650
651 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
652 {
653 int rc;
654 sigset_t sigsaved;
655
656 rerun_vcpu:
657 if (vcpu->sigset_active)
658 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
659
660 atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
661
662 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
663
664 switch (kvm_run->exit_reason) {
665 case KVM_EXIT_S390_SIEIC:
666 case KVM_EXIT_UNKNOWN:
667 case KVM_EXIT_INTR:
668 case KVM_EXIT_S390_RESET:
669 case KVM_EXIT_S390_UCONTROL:
670 case KVM_EXIT_S390_TSCH:
671 break;
672 default:
673 BUG();
674 }
675
676 vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
677 vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
678 if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
679 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
680 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
681 }
682 if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
683 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
684 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
685 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
686 }
687
688 might_fault();
689
690 do {
691 rc = __vcpu_run(vcpu);
692 if (rc)
693 break;
694 if (kvm_is_ucontrol(vcpu->kvm))
695 rc = -EOPNOTSUPP;
696 else
697 rc = kvm_handle_sie_intercept(vcpu);
698 } while (!signal_pending(current) && !rc);
699
700 if (rc == SIE_INTERCEPT_RERUNVCPU)
701 goto rerun_vcpu;
702
703 if (signal_pending(current) && !rc) {
704 kvm_run->exit_reason = KVM_EXIT_INTR;
705 rc = -EINTR;
706 }
707
708 #ifdef CONFIG_KVM_S390_UCONTROL
709 if (rc == SIE_INTERCEPT_UCONTROL) {
710 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
711 kvm_run->s390_ucontrol.trans_exc_code =
712 current->thread.gmap_addr;
713 kvm_run->s390_ucontrol.pgm_code = 0x10;
714 rc = 0;
715 }
716 #endif
717
718 if (rc == -EOPNOTSUPP) {
719 /* intercept cannot be handled in-kernel, prepare kvm-run */
720 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
721 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
722 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
723 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
724 rc = 0;
725 }
726
727 if (rc == -EREMOTE) {
728 /* intercept was handled, but userspace support is needed
729 * kvm_run has been prepared by the handler */
730 rc = 0;
731 }
732
733 kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
734 kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
735 kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
736 memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
737
738 if (vcpu->sigset_active)
739 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
740
741 vcpu->stat.exit_userspace++;
742 return rc;
743 }
744
745 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
746 unsigned long n, int prefix)
747 {
748 if (prefix)
749 return copy_to_guest(vcpu, guestdest, from, n);
750 else
751 return copy_to_guest_absolute(vcpu, guestdest, from, n);
752 }
753
754 /*
755 * store status at address
756 * we use have two special cases:
757 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
758 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
759 */
760 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
761 {
762 unsigned char archmode = 1;
763 int prefix;
764
765 if (addr == KVM_S390_STORE_STATUS_NOADDR) {
766 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
767 return -EFAULT;
768 addr = SAVE_AREA_BASE;
769 prefix = 0;
770 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
771 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
772 return -EFAULT;
773 addr = SAVE_AREA_BASE;
774 prefix = 1;
775 } else
776 prefix = 0;
777
778 /*
779 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
780 * copying in vcpu load/put. Lets update our copies before we save
781 * it into the save area
782 */
783 save_fp_regs(&vcpu->arch.guest_fpregs);
784 save_access_regs(vcpu->run->s.regs.acrs);
785
786 if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
787 vcpu->arch.guest_fpregs.fprs, 128, prefix))
788 return -EFAULT;
789
790 if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
791 vcpu->run->s.regs.gprs, 128, prefix))
792 return -EFAULT;
793
794 if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
795 &vcpu->arch.sie_block->gpsw, 16, prefix))
796 return -EFAULT;
797
798 if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
799 &vcpu->arch.sie_block->prefix, 4, prefix))
800 return -EFAULT;
801
802 if (__guestcopy(vcpu,
803 addr + offsetof(struct save_area, fp_ctrl_reg),
804 &vcpu->arch.guest_fpregs.fpc, 4, prefix))
805 return -EFAULT;
806
807 if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
808 &vcpu->arch.sie_block->todpr, 4, prefix))
809 return -EFAULT;
810
811 if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
812 &vcpu->arch.sie_block->cputm, 8, prefix))
813 return -EFAULT;
814
815 if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
816 &vcpu->arch.sie_block->ckc, 8, prefix))
817 return -EFAULT;
818
819 if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
820 &vcpu->run->s.regs.acrs, 64, prefix))
821 return -EFAULT;
822
823 if (__guestcopy(vcpu,
824 addr + offsetof(struct save_area, ctrl_regs),
825 &vcpu->arch.sie_block->gcr, 128, prefix))
826 return -EFAULT;
827 return 0;
828 }
829
830 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
831 struct kvm_enable_cap *cap)
832 {
833 int r;
834
835 if (cap->flags)
836 return -EINVAL;
837
838 switch (cap->cap) {
839 case KVM_CAP_S390_CSS_SUPPORT:
840 if (!vcpu->kvm->arch.css_support) {
841 vcpu->kvm->arch.css_support = 1;
842 trace_kvm_s390_enable_css(vcpu->kvm);
843 }
844 r = 0;
845 break;
846 default:
847 r = -EINVAL;
848 break;
849 }
850 return r;
851 }
852
853 long kvm_arch_vcpu_ioctl(struct file *filp,
854 unsigned int ioctl, unsigned long arg)
855 {
856 struct kvm_vcpu *vcpu = filp->private_data;
857 void __user *argp = (void __user *)arg;
858 long r;
859
860 switch (ioctl) {
861 case KVM_S390_INTERRUPT: {
862 struct kvm_s390_interrupt s390int;
863
864 r = -EFAULT;
865 if (copy_from_user(&s390int, argp, sizeof(s390int)))
866 break;
867 r = kvm_s390_inject_vcpu(vcpu, &s390int);
868 break;
869 }
870 case KVM_S390_STORE_STATUS:
871 r = kvm_s390_vcpu_store_status(vcpu, arg);
872 break;
873 case KVM_S390_SET_INITIAL_PSW: {
874 psw_t psw;
875
876 r = -EFAULT;
877 if (copy_from_user(&psw, argp, sizeof(psw)))
878 break;
879 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
880 break;
881 }
882 case KVM_S390_INITIAL_RESET:
883 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
884 break;
885 case KVM_SET_ONE_REG:
886 case KVM_GET_ONE_REG: {
887 struct kvm_one_reg reg;
888 r = -EFAULT;
889 if (copy_from_user(&reg, argp, sizeof(reg)))
890 break;
891 if (ioctl == KVM_SET_ONE_REG)
892 r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
893 else
894 r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
895 break;
896 }
897 #ifdef CONFIG_KVM_S390_UCONTROL
898 case KVM_S390_UCAS_MAP: {
899 struct kvm_s390_ucas_mapping ucasmap;
900
901 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
902 r = -EFAULT;
903 break;
904 }
905
906 if (!kvm_is_ucontrol(vcpu->kvm)) {
907 r = -EINVAL;
908 break;
909 }
910
911 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
912 ucasmap.vcpu_addr, ucasmap.length);
913 break;
914 }
915 case KVM_S390_UCAS_UNMAP: {
916 struct kvm_s390_ucas_mapping ucasmap;
917
918 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
919 r = -EFAULT;
920 break;
921 }
922
923 if (!kvm_is_ucontrol(vcpu->kvm)) {
924 r = -EINVAL;
925 break;
926 }
927
928 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
929 ucasmap.length);
930 break;
931 }
932 #endif
933 case KVM_S390_VCPU_FAULT: {
934 r = gmap_fault(arg, vcpu->arch.gmap);
935 if (!IS_ERR_VALUE(r))
936 r = 0;
937 break;
938 }
939 case KVM_ENABLE_CAP:
940 {
941 struct kvm_enable_cap cap;
942 r = -EFAULT;
943 if (copy_from_user(&cap, argp, sizeof(cap)))
944 break;
945 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
946 break;
947 }
948 default:
949 r = -ENOTTY;
950 }
951 return r;
952 }
953
954 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
955 {
956 #ifdef CONFIG_KVM_S390_UCONTROL
957 if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
958 && (kvm_is_ucontrol(vcpu->kvm))) {
959 vmf->page = virt_to_page(vcpu->arch.sie_block);
960 get_page(vmf->page);
961 return 0;
962 }
963 #endif
964 return VM_FAULT_SIGBUS;
965 }
966
967 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
968 struct kvm_memory_slot *dont)
969 {
970 }
971
972 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
973 {
974 return 0;
975 }
976
977 /* Section: memory related */
978 int kvm_arch_prepare_memory_region(struct kvm *kvm,
979 struct kvm_memory_slot *memslot,
980 struct kvm_userspace_memory_region *mem,
981 enum kvm_mr_change change)
982 {
983 /* A few sanity checks. We can have memory slots which have to be
984 located/ended at a segment boundary (1MB). The memory in userland is
985 ok to be fragmented into various different vmas. It is okay to mmap()
986 and munmap() stuff in this slot after doing this call at any time */
987
988 if (mem->userspace_addr & 0xffffful)
989 return -EINVAL;
990
991 if (mem->memory_size & 0xffffful)
992 return -EINVAL;
993
994 return 0;
995 }
996
997 void kvm_arch_commit_memory_region(struct kvm *kvm,
998 struct kvm_userspace_memory_region *mem,
999 const struct kvm_memory_slot *old,
1000 enum kvm_mr_change change)
1001 {
1002 int rc;
1003
1004 /* If the basics of the memslot do not change, we do not want
1005 * to update the gmap. Every update causes several unnecessary
1006 * segment translation exceptions. This is usually handled just
1007 * fine by the normal fault handler + gmap, but it will also
1008 * cause faults on the prefix page of running guest CPUs.
1009 */
1010 if (old->userspace_addr == mem->userspace_addr &&
1011 old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1012 old->npages * PAGE_SIZE == mem->memory_size)
1013 return;
1014
1015 rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1016 mem->guest_phys_addr, mem->memory_size);
1017 if (rc)
1018 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
1019 return;
1020 }
1021
1022 void kvm_arch_flush_shadow_all(struct kvm *kvm)
1023 {
1024 }
1025
1026 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1027 struct kvm_memory_slot *slot)
1028 {
1029 }
1030
1031 static int __init kvm_s390_init(void)
1032 {
1033 int ret;
1034 ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1035 if (ret)
1036 return ret;
1037
1038 /*
1039 * guests can ask for up to 255+1 double words, we need a full page
1040 * to hold the maximum amount of facilities. On the other hand, we
1041 * only set facilities that are known to work in KVM.
1042 */
1043 facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1044 if (!facilities) {
1045 kvm_exit();
1046 return -ENOMEM;
1047 }
1048 memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
1049 facilities[0] &= 0xff00fff3f47c0000ULL;
1050 facilities[1] &= 0x001c000000000000ULL;
1051 return 0;
1052 }
1053
1054 static void __exit kvm_s390_exit(void)
1055 {
1056 free_page((unsigned long) facilities);
1057 kvm_exit();
1058 }
1059
1060 module_init(kvm_s390_init);
1061 module_exit(kvm_s390_exit);
Linux kernel - Deliverables
This page took 0.078305 seconds and 5 git commands to generate.