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