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