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