kvm-s390.c 33.7 KB
Newer Older
1
/*
2
 * hosting zSeries kernel virtual machines
3
 *
4
 * Copyright IBM Corp. 2008, 2009
5 6 7 8 9 10 11 12
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License (version 2 only)
 * as published by the Free Software Foundation.
 *
 *    Author(s): Carsten Otte <cotte@de.ibm.com>
 *               Christian Borntraeger <borntraeger@de.ibm.com>
 *               Heiko Carstens <heiko.carstens@de.ibm.com>
13
 *               Christian Ehrhardt <ehrhardt@de.ibm.com>
14 15 16 17 18
 */

#include <linux/compiler.h>
#include <linux/err.h>
#include <linux/fs.h>
19
#include <linux/hrtimer.h>
20 21 22 23 24
#include <linux/init.h>
#include <linux/kvm.h>
#include <linux/kvm_host.h>
#include <linux/module.h>
#include <linux/slab.h>
25
#include <linux/timer.h>
26
#include <asm/asm-offsets.h>
27 28
#include <asm/lowcore.h>
#include <asm/pgtable.h>
29
#include <asm/nmi.h>
30
#include <asm/switch_to.h>
31
#include <asm/facility.h>
32
#include <asm/sclp.h>
33
#include "kvm-s390.h"
34 35
#include "gaccess.h"

36 37
#define CREATE_TRACE_POINTS
#include "trace.h"
38
#include "trace-s390.h"
39

40 41 42 43
#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU

struct kvm_stats_debugfs_item debugfs_entries[] = {
	{ "userspace_handled", VCPU_STAT(exit_userspace) },
44
	{ "exit_null", VCPU_STAT(exit_null) },
45 46 47 48
	{ "exit_validity", VCPU_STAT(exit_validity) },
	{ "exit_stop_request", VCPU_STAT(exit_stop_request) },
	{ "exit_external_request", VCPU_STAT(exit_external_request) },
	{ "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
49 50 51
	{ "exit_instruction", VCPU_STAT(exit_instruction) },
	{ "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
	{ "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
52
	{ "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
53 54
	{ "instruction_lctl", VCPU_STAT(instruction_lctl) },
	{ "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
55
	{ "deliver_external_call", VCPU_STAT(deliver_external_call) },
56 57 58 59 60 61 62
	{ "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
	{ "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
	{ "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
	{ "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
	{ "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
	{ "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
	{ "exit_wait_state", VCPU_STAT(exit_wait_state) },
63
	{ "instruction_pfmf", VCPU_STAT(instruction_pfmf) },
64 65 66 67 68 69 70 71 72
	{ "instruction_stidp", VCPU_STAT(instruction_stidp) },
	{ "instruction_spx", VCPU_STAT(instruction_spx) },
	{ "instruction_stpx", VCPU_STAT(instruction_stpx) },
	{ "instruction_stap", VCPU_STAT(instruction_stap) },
	{ "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
	{ "instruction_stsch", VCPU_STAT(instruction_stsch) },
	{ "instruction_chsc", VCPU_STAT(instruction_chsc) },
	{ "instruction_stsi", VCPU_STAT(instruction_stsi) },
	{ "instruction_stfl", VCPU_STAT(instruction_stfl) },
73
	{ "instruction_tprot", VCPU_STAT(instruction_tprot) },
74
	{ "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
75
	{ "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
76
	{ "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
77 78 79 80 81
	{ "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
	{ "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
	{ "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
	{ "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
	{ "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
82
	{ "diagnose_10", VCPU_STAT(diagnose_10) },
83
	{ "diagnose_44", VCPU_STAT(diagnose_44) },
84
	{ "diagnose_9c", VCPU_STAT(diagnose_9c) },
85 86 87
	{ NULL }
};

88
unsigned long *vfacilities;
89
static struct gmap_notifier gmap_notifier;
90

91 92 93 94 95 96
/* test availability of vfacility */
static inline int test_vfacility(unsigned long nr)
{
	return __test_facility(nr, (void *) vfacilities);
}

97
/* Section: not file related */
98
int kvm_arch_hardware_enable(void *garbage)
99 100
{
	/* every s390 is virtualization enabled ;-) */
101
	return 0;
102 103 104 105 106 107
}

void kvm_arch_hardware_disable(void *garbage)
{
}

108 109
static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address);

110 111
int kvm_arch_hardware_setup(void)
{
112 113
	gmap_notifier.notifier_call = kvm_gmap_notifier;
	gmap_register_ipte_notifier(&gmap_notifier);
114 115 116 117 118
	return 0;
}

void kvm_arch_hardware_unsetup(void)
{
119
	gmap_unregister_ipte_notifier(&gmap_notifier);
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
}

void kvm_arch_check_processor_compat(void *rtn)
{
}

int kvm_arch_init(void *opaque)
{
	return 0;
}

void kvm_arch_exit(void)
{
}

/* Section: device related */
long kvm_arch_dev_ioctl(struct file *filp,
			unsigned int ioctl, unsigned long arg)
{
	if (ioctl == KVM_S390_ENABLE_SIE)
		return s390_enable_sie();
	return -EINVAL;
}

int kvm_dev_ioctl_check_extension(long ext)
{
146 147
	int r;

148
	switch (ext) {
149
	case KVM_CAP_S390_PSW:
150
	case KVM_CAP_S390_GMAP:
151
	case KVM_CAP_SYNC_MMU:
152 153 154
#ifdef CONFIG_KVM_S390_UCONTROL
	case KVM_CAP_S390_UCONTROL:
#endif
155
	case KVM_CAP_ASYNC_PF:
156
	case KVM_CAP_SYNC_REGS:
157
	case KVM_CAP_ONE_REG:
158
	case KVM_CAP_ENABLE_CAP:
159
	case KVM_CAP_S390_CSS_SUPPORT:
C
Cornelia Huck 已提交
160
	case KVM_CAP_IOEVENTFD:
161
	case KVM_CAP_DEVICE_CTRL:
162 163
		r = 1;
		break;
164 165 166 167
	case KVM_CAP_NR_VCPUS:
	case KVM_CAP_MAX_VCPUS:
		r = KVM_MAX_VCPUS;
		break;
168 169 170
	case KVM_CAP_NR_MEMSLOTS:
		r = KVM_USER_MEM_SLOTS;
		break;
171
	case KVM_CAP_S390_COW:
172
		r = MACHINE_HAS_ESOP;
173
		break;
174
	default:
175
		r = 0;
176
	}
177
	return r;
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
}

/* Section: vm related */
/*
 * Get (and clear) the dirty memory log for a memory slot.
 */
int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
			       struct kvm_dirty_log *log)
{
	return 0;
}

long kvm_arch_vm_ioctl(struct file *filp,
		       unsigned int ioctl, unsigned long arg)
{
	struct kvm *kvm = filp->private_data;
	void __user *argp = (void __user *)arg;
	int r;

	switch (ioctl) {
198 199 200 201 202 203 204 205 206
	case KVM_S390_INTERRUPT: {
		struct kvm_s390_interrupt s390int;

		r = -EFAULT;
		if (copy_from_user(&s390int, argp, sizeof(s390int)))
			break;
		r = kvm_s390_inject_vm(kvm, &s390int);
		break;
	}
207
	default:
208
		r = -ENOTTY;
209 210 211 212 213
	}

	return r;
}

214
int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
215 216 217 218
{
	int rc;
	char debug_name[16];

219 220 221 222 223 224 225 226 227 228 229
	rc = -EINVAL;
#ifdef CONFIG_KVM_S390_UCONTROL
	if (type & ~KVM_VM_S390_UCONTROL)
		goto out_err;
	if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
		goto out_err;
#else
	if (type)
		goto out_err;
#endif

230 231
	rc = s390_enable_sie();
	if (rc)
232
		goto out_err;
233

234 235
	rc = -ENOMEM;

236 237
	kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
	if (!kvm->arch.sca)
238
		goto out_err;
239 240 241 242 243 244 245

	sprintf(debug_name, "kvm-%u", current->pid);

	kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
	if (!kvm->arch.dbf)
		goto out_nodbf;

246 247 248
	spin_lock_init(&kvm->arch.float_int.lock);
	INIT_LIST_HEAD(&kvm->arch.float_int.list);

249 250 251
	debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
	VM_EVENT(kvm, 3, "%s", "vm created");

252 253 254 255 256 257
	if (type & KVM_VM_S390_UCONTROL) {
		kvm->arch.gmap = NULL;
	} else {
		kvm->arch.gmap = gmap_alloc(current->mm);
		if (!kvm->arch.gmap)
			goto out_nogmap;
258
		kvm->arch.gmap->private = kvm;
259
		kvm->arch.gmap->pfault_enabled = 0;
260
	}
261 262 263

	kvm->arch.css_support = 0;

264
	return 0;
265 266
out_nogmap:
	debug_unregister(kvm->arch.dbf);
267 268
out_nodbf:
	free_page((unsigned long)(kvm->arch.sca));
269 270
out_err:
	return rc;
271 272
}

273 274 275
void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
{
	VCPU_EVENT(vcpu, 3, "%s", "free cpu");
276
	trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
277
	kvm_clear_async_pf_completion_queue(vcpu);
C
Carsten Otte 已提交
278 279 280 281 282 283 284
	if (!kvm_is_ucontrol(vcpu->kvm)) {
		clear_bit(63 - vcpu->vcpu_id,
			  (unsigned long *) &vcpu->kvm->arch.sca->mcn);
		if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
		    (__u64) vcpu->arch.sie_block)
			vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
	}
285
	smp_mb();
286 287 288 289

	if (kvm_is_ucontrol(vcpu->kvm))
		gmap_free(vcpu->arch.gmap);

290
	free_page((unsigned long)(vcpu->arch.sie_block));
291
	kvm_vcpu_uninit(vcpu);
292
	kmem_cache_free(kvm_vcpu_cache, vcpu);
293 294 295 296 297
}

static void kvm_free_vcpus(struct kvm *kvm)
{
	unsigned int i;
298
	struct kvm_vcpu *vcpu;
299

300 301 302 303 304 305 306 307 308
	kvm_for_each_vcpu(i, vcpu, kvm)
		kvm_arch_vcpu_destroy(vcpu);

	mutex_lock(&kvm->lock);
	for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
		kvm->vcpus[i] = NULL;

	atomic_set(&kvm->online_vcpus, 0);
	mutex_unlock(&kvm->lock);
309 310
}

311 312 313 314
void kvm_arch_sync_events(struct kvm *kvm)
{
}

315 316
void kvm_arch_destroy_vm(struct kvm *kvm)
{
317
	kvm_free_vcpus(kvm);
318
	free_page((unsigned long)(kvm->arch.sca));
319
	debug_unregister(kvm->arch.dbf);
320 321
	if (!kvm_is_ucontrol(kvm))
		gmap_free(kvm->arch.gmap);
322 323 324 325 326
}

/* Section: vcpu related */
int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
{
327 328
	vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
	kvm_clear_async_pf_completion_queue(vcpu);
329 330 331 332
	if (kvm_is_ucontrol(vcpu->kvm)) {
		vcpu->arch.gmap = gmap_alloc(current->mm);
		if (!vcpu->arch.gmap)
			return -ENOMEM;
333
		vcpu->arch.gmap->private = vcpu->kvm;
334 335 336
		return 0;
	}

337
	vcpu->arch.gmap = vcpu->kvm->arch.gmap;
338 339
	vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
				    KVM_SYNC_GPRS |
340 341
				    KVM_SYNC_ACRS |
				    KVM_SYNC_CRS;
342 343 344 345 346
	return 0;
}

void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
{
347
	/* Nothing todo */
348 349 350 351
}

void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
{
352 353
	save_fp_ctl(&vcpu->arch.host_fpregs.fpc);
	save_fp_regs(vcpu->arch.host_fpregs.fprs);
354
	save_access_regs(vcpu->arch.host_acrs);
355 356
	restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
	restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
357
	restore_access_regs(vcpu->run->s.regs.acrs);
358
	gmap_enable(vcpu->arch.gmap);
359
	atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
360 361 362 363
}

void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
{
364
	atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
365
	gmap_disable(vcpu->arch.gmap);
366 367
	save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
	save_fp_regs(vcpu->arch.guest_fpregs.fprs);
368
	save_access_regs(vcpu->run->s.regs.acrs);
369 370
	restore_fp_ctl(&vcpu->arch.host_fpregs.fpc);
	restore_fp_regs(vcpu->arch.host_fpregs.fprs);
371 372 373 374 375 376 377 378
	restore_access_regs(vcpu->arch.host_acrs);
}

static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
{
	/* this equals initial cpu reset in pop, but we don't switch to ESA */
	vcpu->arch.sie_block->gpsw.mask = 0UL;
	vcpu->arch.sie_block->gpsw.addr = 0UL;
379
	kvm_s390_set_prefix(vcpu, 0);
380 381 382 383 384 385 386 387 388
	vcpu->arch.sie_block->cputm     = 0UL;
	vcpu->arch.sie_block->ckc       = 0UL;
	vcpu->arch.sie_block->todpr     = 0;
	memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
	vcpu->arch.sie_block->gcr[0]  = 0xE0UL;
	vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
	vcpu->arch.guest_fpregs.fpc = 0;
	asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
	vcpu->arch.sie_block->gbea = 1;
389 390
	vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
	kvm_clear_async_pf_completion_queue(vcpu);
391
	atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
392 393
}

394 395 396 397 398
int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
{
	return 0;
}

399 400
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
{
401 402
	atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
						    CPUSTAT_SM |
403 404
						    CPUSTAT_STOPPED |
						    CPUSTAT_GED);
405
	vcpu->arch.sie_block->ecb   = 6;
406 407 408
	if (test_vfacility(50) && test_vfacility(73))
		vcpu->arch.sie_block->ecb |= 0x10;

409
	vcpu->arch.sie_block->ecb2  = 8;
410
	vcpu->arch.sie_block->eca   = 0xC1002001U;
411
	vcpu->arch.sie_block->fac   = (int) (long) vfacilities;
412 413 414 415
	hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
	tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
		     (unsigned long) vcpu);
	vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
416
	get_cpu_id(&vcpu->arch.cpu_id);
417
	vcpu->arch.cpu_id.version = 0xff;
418 419 420 421 422 423
	return 0;
}

struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
				      unsigned int id)
{
424
	struct kvm_vcpu *vcpu;
425
	struct sie_page *sie_page;
426 427 428 429 430 431
	int rc = -EINVAL;

	if (id >= KVM_MAX_VCPUS)
		goto out;

	rc = -ENOMEM;
432

433
	vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
434
	if (!vcpu)
435
		goto out;
436

437 438
	sie_page = (struct sie_page *) get_zeroed_page(GFP_KERNEL);
	if (!sie_page)
439 440
		goto out_free_cpu;

441 442 443
	vcpu->arch.sie_block = &sie_page->sie_block;
	vcpu->arch.sie_block->itdba = (unsigned long) &sie_page->itdb;

444
	vcpu->arch.sie_block->icpua = id;
C
Carsten Otte 已提交
445 446 447 448 449 450 451 452 453 454 455 456 457
	if (!kvm_is_ucontrol(kvm)) {
		if (!kvm->arch.sca) {
			WARN_ON_ONCE(1);
			goto out_free_cpu;
		}
		if (!kvm->arch.sca->cpu[id].sda)
			kvm->arch.sca->cpu[id].sda =
				(__u64) vcpu->arch.sie_block;
		vcpu->arch.sie_block->scaoh =
			(__u32)(((__u64)kvm->arch.sca) >> 32);
		vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
		set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
	}
458

459 460 461
	spin_lock_init(&vcpu->arch.local_int.lock);
	INIT_LIST_HEAD(&vcpu->arch.local_int.list);
	vcpu->arch.local_int.float_int = &kvm->arch.float_int;
462
	spin_lock(&kvm->arch.float_int.lock);
463
	kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
464
	vcpu->arch.local_int.wq = &vcpu->wq;
465
	vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
466
	spin_unlock(&kvm->arch.float_int.lock);
467

468 469
	rc = kvm_vcpu_init(vcpu, kvm, id);
	if (rc)
470
		goto out_free_sie_block;
471 472
	VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
		 vcpu->arch.sie_block);
473
	trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
474 475

	return vcpu;
476 477
out_free_sie_block:
	free_page((unsigned long)(vcpu->arch.sie_block));
478
out_free_cpu:
479
	kmem_cache_free(kvm_vcpu_cache, vcpu);
480
out:
481 482 483 484 485 486 487 488 489 490
	return ERR_PTR(rc);
}

int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
{
	/* kvm common code refers to this, but never calls it */
	BUG();
	return 0;
}

491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
void s390_vcpu_block(struct kvm_vcpu *vcpu)
{
	atomic_set_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
}

void s390_vcpu_unblock(struct kvm_vcpu *vcpu)
{
	atomic_clear_mask(PROG_BLOCK_SIE, &vcpu->arch.sie_block->prog20);
}

/*
 * Kick a guest cpu out of SIE and wait until SIE is not running.
 * If the CPU is not running (e.g. waiting as idle) the function will
 * return immediately. */
void exit_sie(struct kvm_vcpu *vcpu)
{
	atomic_set_mask(CPUSTAT_STOP_INT, &vcpu->arch.sie_block->cpuflags);
	while (vcpu->arch.sie_block->prog0c & PROG_IN_SIE)
		cpu_relax();
}

/* Kick a guest cpu out of SIE and prevent SIE-reentry */
void exit_sie_sync(struct kvm_vcpu *vcpu)
{
	s390_vcpu_block(vcpu);
	exit_sie(vcpu);
}

519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
static void kvm_gmap_notifier(struct gmap *gmap, unsigned long address)
{
	int i;
	struct kvm *kvm = gmap->private;
	struct kvm_vcpu *vcpu;

	kvm_for_each_vcpu(i, vcpu, kvm) {
		/* match against both prefix pages */
		if (vcpu->arch.sie_block->prefix == (address & ~0x1000UL)) {
			VCPU_EVENT(vcpu, 2, "gmap notifier for %lx", address);
			kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
			exit_sie_sync(vcpu);
		}
	}
}

535 536 537 538 539 540 541
int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
{
	/* kvm common code refers to this, but never calls it */
	BUG();
	return 0;
}

542 543 544 545 546 547
static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
					   struct kvm_one_reg *reg)
{
	int r = -EINVAL;

	switch (reg->id) {
548 549 550 551 552 553 554 555
	case KVM_REG_S390_TODPR:
		r = put_user(vcpu->arch.sie_block->todpr,
			     (u32 __user *)reg->addr);
		break;
	case KVM_REG_S390_EPOCHDIFF:
		r = put_user(vcpu->arch.sie_block->epoch,
			     (u64 __user *)reg->addr);
		break;
556 557 558 559 560 561 562 563
	case KVM_REG_S390_CPU_TIMER:
		r = put_user(vcpu->arch.sie_block->cputm,
			     (u64 __user *)reg->addr);
		break;
	case KVM_REG_S390_CLOCK_COMP:
		r = put_user(vcpu->arch.sie_block->ckc,
			     (u64 __user *)reg->addr);
		break;
564 565 566 567 568 569 570 571 572 573 574 575 576
	default:
		break;
	}

	return r;
}

static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
					   struct kvm_one_reg *reg)
{
	int r = -EINVAL;

	switch (reg->id) {
577 578 579 580 581 582 583 584
	case KVM_REG_S390_TODPR:
		r = get_user(vcpu->arch.sie_block->todpr,
			     (u32 __user *)reg->addr);
		break;
	case KVM_REG_S390_EPOCHDIFF:
		r = get_user(vcpu->arch.sie_block->epoch,
			     (u64 __user *)reg->addr);
		break;
585 586 587 588 589 590 591 592
	case KVM_REG_S390_CPU_TIMER:
		r = get_user(vcpu->arch.sie_block->cputm,
			     (u64 __user *)reg->addr);
		break;
	case KVM_REG_S390_CLOCK_COMP:
		r = get_user(vcpu->arch.sie_block->ckc,
			     (u64 __user *)reg->addr);
		break;
593 594 595 596 597 598
	default:
		break;
	}

	return r;
}
599

600 601 602 603 604 605 606 607
static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
{
	kvm_s390_vcpu_initial_reset(vcpu);
	return 0;
}

int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
{
608
	memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
609 610 611 612 613
	return 0;
}

int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
{
614
	memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
615 616 617 618 619 620
	return 0;
}

int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs)
{
621
	memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
622
	memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
623
	restore_access_regs(vcpu->run->s.regs.acrs);
624 625 626 627 628 629
	return 0;
}

int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs)
{
630
	memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
631 632 633 634 635 636
	memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
	return 0;
}

int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
{
637 638
	if (test_fp_ctl(fpu->fpc))
		return -EINVAL;
639
	memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
640 641 642
	vcpu->arch.guest_fpregs.fpc = fpu->fpc;
	restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
	restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
643 644 645 646 647 648 649 650 651 652 653 654 655 656
	return 0;
}

int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
{
	memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
	fpu->fpc = vcpu->arch.guest_fpregs.fpc;
	return 0;
}

static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
{
	int rc = 0;

657
	if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
658
		rc = -EBUSY;
659 660 661 662
	else {
		vcpu->run->psw_mask = psw.mask;
		vcpu->run->psw_addr = psw.addr;
	}
663 664 665 666 667 668 669 670 671
	return rc;
}

int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
				  struct kvm_translation *tr)
{
	return -EINVAL; /* not implemented yet */
}

J
Jan Kiszka 已提交
672 673
int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
					struct kvm_guest_debug *dbg)
674 675 676 677
{
	return -EINVAL; /* not implemented yet */
}

678 679 680 681 682 683 684 685 686 687 688 689
int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
				    struct kvm_mp_state *mp_state)
{
	return -EINVAL; /* not implemented yet */
}

int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
				    struct kvm_mp_state *mp_state)
{
	return -EINVAL; /* not implemented yet */
}

690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
{
	/*
	 * We use MMU_RELOAD just to re-arm the ipte notifier for the
	 * guest prefix page. gmap_ipte_notify will wait on the ptl lock.
	 * This ensures that the ipte instruction for this request has
	 * already finished. We might race against a second unmapper that
	 * wants to set the blocking bit. Lets just retry the request loop.
	 */
	while (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) {
		int rc;
		rc = gmap_ipte_notify(vcpu->arch.gmap,
				      vcpu->arch.sie_block->prefix,
				      PAGE_SIZE * 2);
		if (rc)
			return rc;
		s390_vcpu_unblock(vcpu);
	}
	return 0;
}

711 712 713 714 715 716 717 718 719 720 721
static long kvm_arch_fault_in_sync(struct kvm_vcpu *vcpu)
{
	long rc;
	hva_t fault = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap);
	struct mm_struct *mm = current->mm;
	down_read(&mm->mmap_sem);
	rc = get_user_pages(current, mm, fault, 1, 1, 0, NULL, NULL);
	up_read(&mm->mmap_sem);
	return rc;
}

722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
static void __kvm_inject_pfault_token(struct kvm_vcpu *vcpu, bool start_token,
				      unsigned long token)
{
	struct kvm_s390_interrupt inti;
	inti.parm64 = token;

	if (start_token) {
		inti.type = KVM_S390_INT_PFAULT_INIT;
		WARN_ON_ONCE(kvm_s390_inject_vcpu(vcpu, &inti));
	} else {
		inti.type = KVM_S390_INT_PFAULT_DONE;
		WARN_ON_ONCE(kvm_s390_inject_vm(vcpu->kvm, &inti));
	}
}

void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
				     struct kvm_async_pf *work)
{
	trace_kvm_s390_pfault_init(vcpu, work->arch.pfault_token);
	__kvm_inject_pfault_token(vcpu, true, work->arch.pfault_token);
}

void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
				 struct kvm_async_pf *work)
{
	trace_kvm_s390_pfault_done(vcpu, work->arch.pfault_token);
	__kvm_inject_pfault_token(vcpu, false, work->arch.pfault_token);
}

void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
			       struct kvm_async_pf *work)
{
	/* s390 will always inject the page directly */
}

bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu)
{
	/*
	 * s390 will always inject the page directly,
	 * but we still want check_async_completion to cleanup
	 */
	return true;
}

static int kvm_arch_setup_async_pf(struct kvm_vcpu *vcpu)
{
	hva_t hva;
	struct kvm_arch_async_pf arch;
	int rc;

	if (vcpu->arch.pfault_token == KVM_S390_PFAULT_TOKEN_INVALID)
		return 0;
	if ((vcpu->arch.sie_block->gpsw.mask & vcpu->arch.pfault_select) !=
	    vcpu->arch.pfault_compare)
		return 0;
	if (psw_extint_disabled(vcpu))
		return 0;
	if (kvm_cpu_has_interrupt(vcpu))
		return 0;
	if (!(vcpu->arch.sie_block->gcr[0] & 0x200ul))
		return 0;
	if (!vcpu->arch.gmap->pfault_enabled)
		return 0;

	hva = gmap_fault(current->thread.gmap_addr, vcpu->arch.gmap);
	if (copy_from_guest(vcpu, &arch.pfault_token, vcpu->arch.pfault_token, 8))
		return 0;

	rc = kvm_setup_async_pf(vcpu, current->thread.gmap_addr, hva, &arch);
	return rc;
}

794
static int vcpu_pre_run(struct kvm_vcpu *vcpu)
795
{
796
	int rc, cpuflags;
797

798 799 800 801 802 803 804
	/*
	 * On s390 notifications for arriving pages will be delivered directly
	 * to the guest but the house keeping for completed pfaults is
	 * handled outside the worker.
	 */
	kvm_check_async_pf_completion(vcpu);

805
	memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
806 807 808 809

	if (need_resched())
		schedule();

810 811 812
	if (test_thread_flag(TIF_MCCK_PENDING))
		s390_handle_mcck();

813 814
	if (!kvm_is_ucontrol(vcpu->kvm))
		kvm_s390_deliver_pending_interrupts(vcpu);
C
Carsten Otte 已提交
815

816 817 818 819
	rc = kvm_s390_handle_requests(vcpu);
	if (rc)
		return rc;

820
	vcpu->arch.sie_block->icptcode = 0;
821 822 823
	cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
	VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
	trace_kvm_s390_sie_enter(vcpu, cpuflags);
824

825 826 827 828 829
	return 0;
}

static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
{
830
	int rc = -1;
831 832 833 834 835

	VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
		   vcpu->arch.sie_block->icptcode);
	trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);

836
	if (exit_reason >= 0) {
837
		rc = 0;
838 839 840 841 842 843
	} else if (kvm_is_ucontrol(vcpu->kvm)) {
		vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
		vcpu->run->s390_ucontrol.trans_exc_code =
						current->thread.gmap_addr;
		vcpu->run->s390_ucontrol.pgm_code = 0x10;
		rc = -EREMOTE;
844 845

	} else if (current->thread.gmap_pfault) {
846
		trace_kvm_s390_major_guest_pfault(vcpu);
847
		current->thread.gmap_pfault = 0;
848 849
		if (kvm_arch_setup_async_pf(vcpu) ||
		    (kvm_arch_fault_in_sync(vcpu) >= 0))
850 851 852 853
			rc = 0;
	}

	if (rc == -1) {
854 855 856
		VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
		trace_kvm_s390_sie_fault(vcpu);
		rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
857
	}
858

859
	memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
860

861 862 863 864 865 866 867
	if (rc == 0) {
		if (kvm_is_ucontrol(vcpu->kvm))
			rc = -EOPNOTSUPP;
		else
			rc = kvm_handle_sie_intercept(vcpu);
	}

868 869 870 871 872 873 874
	return rc;
}

static int __vcpu_run(struct kvm_vcpu *vcpu)
{
	int rc, exit_reason;

875 876 877 878 879 880
	/*
	 * We try to hold kvm->srcu during most of vcpu_run (except when run-
	 * ning the guest), so that memslots (and other stuff) are protected
	 */
	vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);

881 882 883 884
	do {
		rc = vcpu_pre_run(vcpu);
		if (rc)
			break;
885

886
		srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
887 888 889 890 891 892 893 894 895 896
		/*
		 * As PF_VCPU will be used in fault handler, between
		 * guest_enter and guest_exit should be no uaccess.
		 */
		preempt_disable();
		kvm_guest_enter();
		preempt_enable();
		exit_reason = sie64a(vcpu->arch.sie_block,
				     vcpu->run->s.regs.gprs);
		kvm_guest_exit();
897
		vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
898 899 900

		rc = vcpu_post_run(vcpu, exit_reason);
	} while (!signal_pending(current) && !rc);
901

902
	srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
903
	return rc;
904 905 906 907
}

int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
{
908
	int rc;
909 910 911 912 913
	sigset_t sigsaved;

	if (vcpu->sigset_active)
		sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);

914
	atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
915

916 917
	BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);

918 919 920
	switch (kvm_run->exit_reason) {
	case KVM_EXIT_S390_SIEIC:
	case KVM_EXIT_UNKNOWN:
921
	case KVM_EXIT_INTR:
922
	case KVM_EXIT_S390_RESET:
923
	case KVM_EXIT_S390_UCONTROL:
924
	case KVM_EXIT_S390_TSCH:
925 926 927 928 929
		break;
	default:
		BUG();
	}

930 931
	vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
	vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
932 933 934 935
	if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
		kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
		kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
	}
936 937 938 939 940
	if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
		kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
		memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
		kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
	}
941

942
	might_fault();
943
	rc = __vcpu_run(vcpu);
944

945 946
	if (signal_pending(current) && !rc) {
		kvm_run->exit_reason = KVM_EXIT_INTR;
947
		rc = -EINTR;
948
	}
949

950
	if (rc == -EOPNOTSUPP) {
951 952 953 954 955 956 957 958 959 960 961 962 963
		/* intercept cannot be handled in-kernel, prepare kvm-run */
		kvm_run->exit_reason         = KVM_EXIT_S390_SIEIC;
		kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
		kvm_run->s390_sieic.ipa      = vcpu->arch.sie_block->ipa;
		kvm_run->s390_sieic.ipb      = vcpu->arch.sie_block->ipb;
		rc = 0;
	}

	if (rc == -EREMOTE) {
		/* intercept was handled, but userspace support is needed
		 * kvm_run has been prepared by the handler */
		rc = 0;
	}
964

965 966
	kvm_run->psw_mask     = vcpu->arch.sie_block->gpsw.mask;
	kvm_run->psw_addr     = vcpu->arch.sie_block->gpsw.addr;
967
	kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
968
	memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
969

970 971 972 973
	if (vcpu->sigset_active)
		sigprocmask(SIG_SETMASK, &sigsaved, NULL);

	vcpu->stat.exit_userspace++;
974
	return rc;
975 976
}

977
static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
978 979 980 981 982 983 984 985 986 987 988 989 990 991
		       unsigned long n, int prefix)
{
	if (prefix)
		return copy_to_guest(vcpu, guestdest, from, n);
	else
		return copy_to_guest_absolute(vcpu, guestdest, from, n);
}

/*
 * store status at address
 * we use have two special cases:
 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
 */
992
int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr)
993
{
994
	unsigned char archmode = 1;
995
	int prefix;
996
	u64 clkcomp;
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010

	if (addr == KVM_S390_STORE_STATUS_NOADDR) {
		if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
			return -EFAULT;
		addr = SAVE_AREA_BASE;
		prefix = 0;
	} else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
		if (copy_to_guest(vcpu, 163ul, &archmode, 1))
			return -EFAULT;
		addr = SAVE_AREA_BASE;
		prefix = 1;
	} else
		prefix = 0;

1011
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
1012 1013 1014
			vcpu->arch.guest_fpregs.fprs, 128, prefix))
		return -EFAULT;

1015
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
1016
			vcpu->run->s.regs.gprs, 128, prefix))
1017 1018
		return -EFAULT;

1019
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
1020 1021 1022
			&vcpu->arch.sie_block->gpsw, 16, prefix))
		return -EFAULT;

1023
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
1024 1025 1026 1027
			&vcpu->arch.sie_block->prefix, 4, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu,
1028
			addr + offsetof(struct save_area, fp_ctrl_reg),
1029 1030 1031
			&vcpu->arch.guest_fpregs.fpc, 4, prefix))
		return -EFAULT;

1032
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
1033 1034 1035
			&vcpu->arch.sie_block->todpr, 4, prefix))
		return -EFAULT;

1036
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
1037 1038 1039
			&vcpu->arch.sie_block->cputm, 8, prefix))
		return -EFAULT;

1040
	clkcomp = vcpu->arch.sie_block->ckc >> 8;
1041
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
1042
			&clkcomp, 8, prefix))
1043 1044
		return -EFAULT;

1045
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
1046
			&vcpu->run->s.regs.acrs, 64, prefix))
1047 1048 1049
		return -EFAULT;

	if (__guestcopy(vcpu,
1050
			addr + offsetof(struct save_area, ctrl_regs),
1051 1052 1053 1054 1055
			&vcpu->arch.sie_block->gcr, 128, prefix))
		return -EFAULT;
	return 0;
}

1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
{
	/*
	 * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
	 * copying in vcpu load/put. Lets update our copies before we save
	 * it into the save area
	 */
	save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
	save_fp_regs(vcpu->arch.guest_fpregs.fprs);
	save_access_regs(vcpu->run->s.regs.acrs);

	return kvm_s390_store_status_unloaded(vcpu, addr);
}

1070 1071 1072 1073 1074 1075 1076 1077 1078
static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
				     struct kvm_enable_cap *cap)
{
	int r;

	if (cap->flags)
		return -EINVAL;

	switch (cap->cap) {
1079 1080 1081 1082 1083 1084 1085
	case KVM_CAP_S390_CSS_SUPPORT:
		if (!vcpu->kvm->arch.css_support) {
			vcpu->kvm->arch.css_support = 1;
			trace_kvm_s390_enable_css(vcpu->kvm);
		}
		r = 0;
		break;
1086 1087 1088 1089 1090 1091 1092
	default:
		r = -EINVAL;
		break;
	}
	return r;
}

1093 1094 1095 1096 1097
long kvm_arch_vcpu_ioctl(struct file *filp,
			 unsigned int ioctl, unsigned long arg)
{
	struct kvm_vcpu *vcpu = filp->private_data;
	void __user *argp = (void __user *)arg;
1098
	int idx;
1099
	long r;
1100

1101 1102
	switch (ioctl) {
	case KVM_S390_INTERRUPT: {
1103 1104
		struct kvm_s390_interrupt s390int;

1105
		r = -EFAULT;
1106
		if (copy_from_user(&s390int, argp, sizeof(s390int)))
1107 1108 1109
			break;
		r = kvm_s390_inject_vcpu(vcpu, &s390int);
		break;
1110
	}
1111
	case KVM_S390_STORE_STATUS:
1112
		idx = srcu_read_lock(&vcpu->kvm->srcu);
1113
		r = kvm_s390_vcpu_store_status(vcpu, arg);
1114
		srcu_read_unlock(&vcpu->kvm->srcu, idx);
1115
		break;
1116 1117 1118
	case KVM_S390_SET_INITIAL_PSW: {
		psw_t psw;

1119
		r = -EFAULT;
1120
		if (copy_from_user(&psw, argp, sizeof(psw)))
1121 1122 1123
			break;
		r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
		break;
1124 1125
	}
	case KVM_S390_INITIAL_RESET:
1126 1127
		r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
		break;
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	case KVM_SET_ONE_REG:
	case KVM_GET_ONE_REG: {
		struct kvm_one_reg reg;
		r = -EFAULT;
		if (copy_from_user(&reg, argp, sizeof(reg)))
			break;
		if (ioctl == KVM_SET_ONE_REG)
			r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
		else
			r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
		break;
	}
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
#ifdef CONFIG_KVM_S390_UCONTROL
	case KVM_S390_UCAS_MAP: {
		struct kvm_s390_ucas_mapping ucasmap;

		if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
			r = -EFAULT;
			break;
		}

		if (!kvm_is_ucontrol(vcpu->kvm)) {
			r = -EINVAL;
			break;
		}

		r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
				     ucasmap.vcpu_addr, ucasmap.length);
		break;
	}
	case KVM_S390_UCAS_UNMAP: {
		struct kvm_s390_ucas_mapping ucasmap;

		if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
			r = -EFAULT;
			break;
		}

		if (!kvm_is_ucontrol(vcpu->kvm)) {
			r = -EINVAL;
			break;
		}

		r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
			ucasmap.length);
		break;
	}
#endif
1176 1177 1178 1179 1180 1181
	case KVM_S390_VCPU_FAULT: {
		r = gmap_fault(arg, vcpu->arch.gmap);
		if (!IS_ERR_VALUE(r))
			r = 0;
		break;
	}
1182 1183 1184 1185 1186 1187 1188 1189 1190
	case KVM_ENABLE_CAP:
	{
		struct kvm_enable_cap cap;
		r = -EFAULT;
		if (copy_from_user(&cap, argp, sizeof(cap)))
			break;
		r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
		break;
	}
1191
	default:
1192
		r = -ENOTTY;
1193
	}
1194
	return r;
1195 1196
}

1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
{
#ifdef CONFIG_KVM_S390_UCONTROL
	if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
		 && (kvm_is_ucontrol(vcpu->kvm))) {
		vmf->page = virt_to_page(vcpu->arch.sie_block);
		get_page(vmf->page);
		return 0;
	}
#endif
	return VM_FAULT_SIGBUS;
}

1210
void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
1211 1212 1213 1214
			   struct kvm_memory_slot *dont)
{
}

1215 1216
int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
			    unsigned long npages)
1217 1218 1219 1220
{
	return 0;
}

1221 1222 1223 1224
void kvm_arch_memslots_updated(struct kvm *kvm)
{
}

1225
/* Section: memory related */
1226 1227
int kvm_arch_prepare_memory_region(struct kvm *kvm,
				   struct kvm_memory_slot *memslot,
1228 1229
				   struct kvm_userspace_memory_region *mem,
				   enum kvm_mr_change change)
1230
{
1231 1232 1233 1234
	/* A few sanity checks. We can have memory slots which have to be
	   located/ended at a segment boundary (1MB). The memory in userland is
	   ok to be fragmented into various different vmas. It is okay to mmap()
	   and munmap() stuff in this slot after doing this call at any time */
1235

1236
	if (mem->userspace_addr & 0xffffful)
1237 1238
		return -EINVAL;

1239
	if (mem->memory_size & 0xffffful)
1240 1241
		return -EINVAL;

1242 1243 1244 1245 1246
	return 0;
}

void kvm_arch_commit_memory_region(struct kvm *kvm,
				struct kvm_userspace_memory_region *mem,
1247 1248
				const struct kvm_memory_slot *old,
				enum kvm_mr_change change)
1249
{
1250
	int rc;
1251

1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
	/* If the basics of the memslot do not change, we do not want
	 * to update the gmap. Every update causes several unnecessary
	 * segment translation exceptions. This is usually handled just
	 * fine by the normal fault handler + gmap, but it will also
	 * cause faults on the prefix page of running guest CPUs.
	 */
	if (old->userspace_addr == mem->userspace_addr &&
	    old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
	    old->npages * PAGE_SIZE == mem->memory_size)
		return;
1262 1263 1264 1265

	rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
		mem->guest_phys_addr, mem->memory_size);
	if (rc)
1266
		printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
1267
	return;
1268 1269
}

1270 1271 1272 1273 1274 1275
void kvm_arch_flush_shadow_all(struct kvm *kvm)
{
}

void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
				   struct kvm_memory_slot *slot)
1276 1277 1278
{
}

1279 1280
static int __init kvm_s390_init(void)
{
1281
	int ret;
1282
	ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1283 1284 1285 1286 1287
	if (ret)
		return ret;

	/*
	 * guests can ask for up to 255+1 double words, we need a full page
L
Lucas De Marchi 已提交
1288
	 * to hold the maximum amount of facilities. On the other hand, we
1289 1290
	 * only set facilities that are known to work in KVM.
	 */
1291 1292
	vfacilities = (unsigned long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
	if (!vfacilities) {
1293 1294 1295
		kvm_exit();
		return -ENOMEM;
	}
1296
	memcpy(vfacilities, S390_lowcore.stfle_fac_list, 16);
1297
	vfacilities[0] &= 0xff82fff3f4fc2000UL;
1298
	vfacilities[1] &= 0x005c000000000000UL;
1299
	return 0;
1300 1301 1302 1303
}

static void __exit kvm_s390_exit(void)
{
1304
	free_page((unsigned long) vfacilities);
1305 1306 1307 1308 1309
	kvm_exit();
}

module_init(kvm_s390_init);
module_exit(kvm_s390_exit);
1310 1311 1312 1313 1314 1315 1316 1317 1318

/*
 * Enable autoloading of the kvm module.
 * Note that we add the module alias here instead of virt/kvm/kvm_main.c
 * since x86 takes a different approach.
 */
#include <linux/miscdevice.h>
MODULE_ALIAS_MISCDEV(KVM_MINOR);
MODULE_ALIAS("devname:kvm");