kvm-s390.c 30.6 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_SYNC_REGS:
156
	case KVM_CAP_ONE_REG:
157
	case KVM_CAP_ENABLE_CAP:
158
	case KVM_CAP_S390_CSS_SUPPORT:
C
Cornelia Huck 已提交
159
	case KVM_CAP_IOEVENTFD:
160 161
		r = 1;
		break;
162 163 164 165
	case KVM_CAP_NR_VCPUS:
	case KVM_CAP_MAX_VCPUS:
		r = KVM_MAX_VCPUS;
		break;
166 167 168
	case KVM_CAP_NR_MEMSLOTS:
		r = KVM_USER_MEM_SLOTS;
		break;
169
	case KVM_CAP_S390_COW:
170
		r = MACHINE_HAS_ESOP;
171
		break;
172
	default:
173
		r = 0;
174
	}
175
	return r;
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
}

/* 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) {
196 197 198 199 200 201 202 203 204
	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;
	}
205
	default:
206
		r = -ENOTTY;
207 208 209 210 211
	}

	return r;
}

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

217 218 219 220 221 222 223 224 225 226 227
	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

228 229
	rc = s390_enable_sie();
	if (rc)
230
		goto out_err;
231

232 233
	rc = -ENOMEM;

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

	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;

244 245 246
	spin_lock_init(&kvm->arch.float_int.lock);
	INIT_LIST_HEAD(&kvm->arch.float_int.list);

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

250 251 252 253 254 255
	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;
256
		kvm->arch.gmap->private = kvm;
257
	}
258 259 260

	kvm->arch.css_support = 0;

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

270 271 272
void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
{
	VCPU_EVENT(vcpu, 3, "%s", "free cpu");
273
	trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
C
Carsten Otte 已提交
274 275 276 277 278 279 280
	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;
	}
281
	smp_mb();
282 283 284 285

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

286
	free_page((unsigned long)(vcpu->arch.sie_block));
287
	kvm_vcpu_uninit(vcpu);
288
	kmem_cache_free(kvm_vcpu_cache, vcpu);
289 290 291 292 293
}

static void kvm_free_vcpus(struct kvm *kvm)
{
	unsigned int i;
294
	struct kvm_vcpu *vcpu;
295

296 297 298 299 300 301 302 303 304
	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);
305 306
}

307 308 309 310
void kvm_arch_sync_events(struct kvm *kvm)
{
}

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

/* Section: vcpu related */
int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
{
323 324 325 326
	if (kvm_is_ucontrol(vcpu->kvm)) {
		vcpu->arch.gmap = gmap_alloc(current->mm);
		if (!vcpu->arch.gmap)
			return -ENOMEM;
327
		vcpu->arch.gmap->private = vcpu->kvm;
328 329 330
		return 0;
	}

331
	vcpu->arch.gmap = vcpu->kvm->arch.gmap;
332 333
	vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
				    KVM_SYNC_GPRS |
334 335
				    KVM_SYNC_ACRS |
				    KVM_SYNC_CRS;
336 337 338 339 340
	return 0;
}

void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
{
341
	/* Nothing todo */
342 343 344 345
}

void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
{
346 347
	save_fp_ctl(&vcpu->arch.host_fpregs.fpc);
	save_fp_regs(vcpu->arch.host_fpregs.fprs);
348
	save_access_regs(vcpu->arch.host_acrs);
349 350
	restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
	restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
351
	restore_access_regs(vcpu->run->s.regs.acrs);
352
	gmap_enable(vcpu->arch.gmap);
353
	atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
354 355 356 357
}

void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
{
358
	atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
359
	gmap_disable(vcpu->arch.gmap);
360 361
	save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
	save_fp_regs(vcpu->arch.guest_fpregs.fprs);
362
	save_access_regs(vcpu->run->s.regs.acrs);
363 364
	restore_fp_ctl(&vcpu->arch.host_fpregs.fpc);
	restore_fp_regs(vcpu->arch.host_fpregs.fprs);
365 366 367 368 369 370 371 372
	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;
373
	kvm_s390_set_prefix(vcpu, 0);
374 375 376 377 378 379 380 381 382
	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;
383
	atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
384 385
}

386 387 388 389 390
int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
{
	return 0;
}

391 392
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
{
393 394
	atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
						    CPUSTAT_SM |
395 396
						    CPUSTAT_STOPPED |
						    CPUSTAT_GED);
397
	vcpu->arch.sie_block->ecb   = 6;
398
	vcpu->arch.sie_block->ecb2  = 8;
399
	vcpu->arch.sie_block->eca   = 0xC1002001U;
400
	vcpu->arch.sie_block->fac   = (int) (long) vfacilities;
401 402 403 404
	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;
405
	get_cpu_id(&vcpu->arch.cpu_id);
406
	vcpu->arch.cpu_id.version = 0xff;
407 408 409 410 411 412
	return 0;
}

struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
				      unsigned int id)
{
413 414 415 416 417 418 419
	struct kvm_vcpu *vcpu;
	int rc = -EINVAL;

	if (id >= KVM_MAX_VCPUS)
		goto out;

	rc = -ENOMEM;
420

421
	vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
422
	if (!vcpu)
423
		goto out;
424

425 426
	vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
					get_zeroed_page(GFP_KERNEL);
427 428 429 430 431

	if (!vcpu->arch.sie_block)
		goto out_free_cpu;

	vcpu->arch.sie_block->icpua = id;
C
Carsten Otte 已提交
432 433 434 435 436 437 438 439 440 441 442 443 444
	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);
	}
445

446 447 448
	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;
449
	spin_lock(&kvm->arch.float_int.lock);
450
	kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
451
	vcpu->arch.local_int.wq = &vcpu->wq;
452
	vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
453
	spin_unlock(&kvm->arch.float_int.lock);
454

455 456
	rc = kvm_vcpu_init(vcpu, kvm, id);
	if (rc)
457
		goto out_free_sie_block;
458 459
	VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
		 vcpu->arch.sie_block);
460
	trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
461 462

	return vcpu;
463 464
out_free_sie_block:
	free_page((unsigned long)(vcpu->arch.sie_block));
465
out_free_cpu:
466
	kmem_cache_free(kvm_vcpu_cache, vcpu);
467
out:
468 469 470 471 472 473 474 475 476 477
	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;
}

478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
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);
}

506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
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);
		}
	}
}

522 523 524 525 526 527 528
int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
{
	/* kvm common code refers to this, but never calls it */
	BUG();
	return 0;
}

529 530 531 532 533 534
static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
					   struct kvm_one_reg *reg)
{
	int r = -EINVAL;

	switch (reg->id) {
535 536 537 538 539 540 541 542
	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;
543 544 545 546 547 548 549 550
	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;
551 552 553 554 555 556 557 558 559 560 561 562 563
	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) {
564 565 566 567 568 569 570 571
	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;
572 573 574 575 576 577 578 579
	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;
580 581 582 583 584 585
	default:
		break;
	}

	return r;
}
586

587 588 589 590 591 592 593 594
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)
{
595
	memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
596 597 598 599 600
	return 0;
}

int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
{
601
	memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
602 603 604 605 606 607
	return 0;
}

int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs)
{
608
	memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
609
	memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
610
	restore_access_regs(vcpu->run->s.regs.acrs);
611 612 613 614 615 616
	return 0;
}

int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs)
{
617
	memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
618 619 620 621 622 623
	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)
{
624 625
	if (test_fp_ctl(fpu->fpc))
		return -EINVAL;
626
	memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
627 628 629
	vcpu->arch.guest_fpregs.fpc = fpu->fpc;
	restore_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
	restore_fp_regs(vcpu->arch.guest_fpregs.fprs);
630 631 632 633 634 635 636 637 638 639 640 641 642 643
	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;

644
	if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
645
		rc = -EBUSY;
646 647 648 649
	else {
		vcpu->run->psw_mask = psw.mask;
		vcpu->run->psw_addr = psw.addr;
	}
650 651 652 653 654 655 656 657 658
	return rc;
}

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

J
Jan Kiszka 已提交
659 660
int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
					struct kvm_guest_debug *dbg)
661 662 663 664
{
	return -EINVAL; /* not implemented yet */
}

665 666 667 668 669 670 671 672 673 674 675 676
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 */
}

677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
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;
}

698
static int vcpu_pre_run(struct kvm_vcpu *vcpu)
699
{
700
	int rc, cpuflags;
701

702
	memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
703 704 705 706

	if (need_resched())
		schedule();

707 708 709
	if (test_thread_flag(TIF_MCCK_PENDING))
		s390_handle_mcck();

710 711
	if (!kvm_is_ucontrol(vcpu->kvm))
		kvm_s390_deliver_pending_interrupts(vcpu);
C
Carsten Otte 已提交
712

713 714 715 716
	rc = kvm_s390_handle_requests(vcpu);
	if (rc)
		return rc;

717
	vcpu->arch.sie_block->icptcode = 0;
718 719 720
	cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
	VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
	trace_kvm_s390_sie_enter(vcpu, cpuflags);
721

722 723 724 725 726 727
	return 0;
}

static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
{
	int rc;
728 729 730 731 732

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

733
	if (exit_reason >= 0) {
734
		rc = 0;
735 736 737 738 739 740
	} 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;
741 742 743 744
	} else {
		VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
		trace_kvm_s390_sie_fault(vcpu);
		rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
745
	}
746

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

749 750 751 752 753 754 755
	if (rc == 0) {
		if (kvm_is_ucontrol(vcpu->kvm))
			rc = -EOPNOTSUPP;
		else
			rc = kvm_handle_sie_intercept(vcpu);
	}

756 757 758 759 760 761 762
	return rc;
}

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

763 764 765 766 767 768
	/*
	 * 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);

769 770 771 772
	do {
		rc = vcpu_pre_run(vcpu);
		if (rc)
			break;
773

774
		srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
775 776 777 778 779 780 781 782 783 784
		/*
		 * 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();
785
		vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
786 787 788

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

790
	srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
791
	return rc;
792 793 794 795
}

int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
{
796
	int rc;
797 798 799 800 801
	sigset_t sigsaved;

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

802
	atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
803

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

806 807 808
	switch (kvm_run->exit_reason) {
	case KVM_EXIT_S390_SIEIC:
	case KVM_EXIT_UNKNOWN:
809
	case KVM_EXIT_INTR:
810
	case KVM_EXIT_S390_RESET:
811
	case KVM_EXIT_S390_UCONTROL:
812
	case KVM_EXIT_S390_TSCH:
813 814 815 816 817
		break;
	default:
		BUG();
	}

818 819
	vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
	vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
820 821 822 823
	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);
	}
824 825 826 827 828
	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);
	}
829

830
	might_fault();
831
	rc = __vcpu_run(vcpu);
832

833 834
	if (signal_pending(current) && !rc) {
		kvm_run->exit_reason = KVM_EXIT_INTR;
835
		rc = -EINTR;
836
	}
837

838
	if (rc == -EOPNOTSUPP) {
839 840 841 842 843 844 845 846 847 848 849 850 851
		/* 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;
	}
852

853 854
	kvm_run->psw_mask     = vcpu->arch.sie_block->gpsw.mask;
	kvm_run->psw_addr     = vcpu->arch.sie_block->gpsw.addr;
855
	kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
856
	memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
857

858 859 860 861
	if (vcpu->sigset_active)
		sigprocmask(SIG_SETMASK, &sigsaved, NULL);

	vcpu->stat.exit_userspace++;
862
	return rc;
863 864
}

865
static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
866 867 868 869 870 871 872 873 874 875 876 877 878 879
		       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
 */
880
int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr)
881
{
882
	unsigned char archmode = 1;
883
	int prefix;
884
	u64 clkcomp;
885 886 887 888 889 890 891 892 893 894 895 896 897 898

	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;

899
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
900 901 902
			vcpu->arch.guest_fpregs.fprs, 128, prefix))
		return -EFAULT;

903
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
904
			vcpu->run->s.regs.gprs, 128, prefix))
905 906
		return -EFAULT;

907
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
908 909 910
			&vcpu->arch.sie_block->gpsw, 16, prefix))
		return -EFAULT;

911
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
912 913 914 915
			&vcpu->arch.sie_block->prefix, 4, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu,
916
			addr + offsetof(struct save_area, fp_ctrl_reg),
917 918 919
			&vcpu->arch.guest_fpregs.fpc, 4, prefix))
		return -EFAULT;

920
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
921 922 923
			&vcpu->arch.sie_block->todpr, 4, prefix))
		return -EFAULT;

924
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
925 926 927
			&vcpu->arch.sie_block->cputm, 8, prefix))
		return -EFAULT;

928
	clkcomp = vcpu->arch.sie_block->ckc >> 8;
929
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
930
			&clkcomp, 8, prefix))
931 932
		return -EFAULT;

933
	if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
934
			&vcpu->run->s.regs.acrs, 64, prefix))
935 936 937
		return -EFAULT;

	if (__guestcopy(vcpu,
938
			addr + offsetof(struct save_area, ctrl_regs),
939 940 941 942 943
			&vcpu->arch.sie_block->gcr, 128, prefix))
		return -EFAULT;
	return 0;
}

944 945 946 947 948 949 950 951 952 953 954 955 956 957
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);
}

958 959 960 961 962 963 964 965 966
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) {
967 968 969 970 971 972 973
	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;
974 975 976 977 978 979 980
	default:
		r = -EINVAL;
		break;
	}
	return r;
}

981 982 983 984 985
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;
986
	int idx;
987
	long r;
988

989 990
	switch (ioctl) {
	case KVM_S390_INTERRUPT: {
991 992
		struct kvm_s390_interrupt s390int;

993
		r = -EFAULT;
994
		if (copy_from_user(&s390int, argp, sizeof(s390int)))
995 996 997
			break;
		r = kvm_s390_inject_vcpu(vcpu, &s390int);
		break;
998
	}
999
	case KVM_S390_STORE_STATUS:
1000
		idx = srcu_read_lock(&vcpu->kvm->srcu);
1001
		r = kvm_s390_vcpu_store_status(vcpu, arg);
1002
		srcu_read_unlock(&vcpu->kvm->srcu, idx);
1003
		break;
1004 1005 1006
	case KVM_S390_SET_INITIAL_PSW: {
		psw_t psw;

1007
		r = -EFAULT;
1008
		if (copy_from_user(&psw, argp, sizeof(psw)))
1009 1010 1011
			break;
		r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
		break;
1012 1013
	}
	case KVM_S390_INITIAL_RESET:
1014 1015
		r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
		break;
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
	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;
	}
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
#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
1064 1065 1066 1067 1068 1069
	case KVM_S390_VCPU_FAULT: {
		r = gmap_fault(arg, vcpu->arch.gmap);
		if (!IS_ERR_VALUE(r))
			r = 0;
		break;
	}
1070 1071 1072 1073 1074 1075 1076 1077 1078
	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;
	}
1079
	default:
1080
		r = -ENOTTY;
1081
	}
1082
	return r;
1083 1084
}

1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
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;
}

1098
void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
1099 1100 1101 1102
			   struct kvm_memory_slot *dont)
{
}

1103 1104
int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
			    unsigned long npages)
1105 1106 1107 1108
{
	return 0;
}

1109 1110 1111 1112
void kvm_arch_memslots_updated(struct kvm *kvm)
{
}

1113
/* Section: memory related */
1114 1115
int kvm_arch_prepare_memory_region(struct kvm *kvm,
				   struct kvm_memory_slot *memslot,
1116 1117
				   struct kvm_userspace_memory_region *mem,
				   enum kvm_mr_change change)
1118
{
1119 1120 1121 1122
	/* 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 */
1123

1124
	if (mem->userspace_addr & 0xffffful)
1125 1126
		return -EINVAL;

1127
	if (mem->memory_size & 0xffffful)
1128 1129
		return -EINVAL;

1130 1131 1132 1133 1134
	return 0;
}

void kvm_arch_commit_memory_region(struct kvm *kvm,
				struct kvm_userspace_memory_region *mem,
1135 1136
				const struct kvm_memory_slot *old,
				enum kvm_mr_change change)
1137
{
1138
	int rc;
1139

1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
	/* 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;
1150 1151 1152 1153

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

1158 1159 1160 1161 1162 1163
void kvm_arch_flush_shadow_all(struct kvm *kvm)
{
}

void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
				   struct kvm_memory_slot *slot)
1164 1165 1166
{
}

1167 1168
static int __init kvm_s390_init(void)
{
1169
	int ret;
1170
	ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1171 1172 1173 1174 1175
	if (ret)
		return ret;

	/*
	 * guests can ask for up to 255+1 double words, we need a full page
L
Lucas De Marchi 已提交
1176
	 * to hold the maximum amount of facilities. On the other hand, we
1177 1178
	 * only set facilities that are known to work in KVM.
	 */
1179 1180
	vfacilities = (unsigned long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
	if (!vfacilities) {
1181 1182 1183
		kvm_exit();
		return -ENOMEM;
	}
1184 1185 1186
	memcpy(vfacilities, S390_lowcore.stfle_fac_list, 16);
	vfacilities[0] &= 0xff82fff3f47c0000UL;
	vfacilities[1] &= 0x001c000000000000UL;
1187
	return 0;
1188 1189 1190 1191
}

static void __exit kvm_s390_exit(void)
{
1192
	free_page((unsigned long) vfacilities);
1193 1194 1195 1196 1197
	kvm_exit();
}

module_init(kvm_s390_init);
module_exit(kvm_s390_exit);
1198 1199 1200 1201 1202 1203 1204 1205 1206

/*
 * 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");