[mirror_ubuntu-artful-kernel.git] / arch / s390 / kvm / kvm-s390.c

/*
 * s390host.c --  hosting zSeries kernel virtual machines
 *
 * Copyright IBM Corp. 2008
 *
 * 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>
 */

#include <linux/compiler.h>
#include <linux/err.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kvm.h>
#include <linux/kvm_host.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/timer.h>
#include <asm/lowcore.h>
#include <asm/pgtable.h>

#include "kvm-s390.h"
#include "gaccess.h"

#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) },
	{ "exit_null", VCPU_STAT(exit_null) },
	{ "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) },
	{ "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) },
	{ "instruction_lctg", VCPU_STAT(instruction_lctg) },
	{ "instruction_lctl", VCPU_STAT(instruction_lctl) },
	{ "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
	{ "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) },
	{ "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) },
	{ "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
	{ "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) },
	{ "diagnose_44", VCPU_STAT(diagnose_44) },
	{ NULL }
};


/* Section: not file related */
void kvm_arch_hardware_enable(void *garbage)
{
	/* every s390 is virtualization enabled ;-) */
}

void kvm_arch_hardware_disable(void *garbage)
{
}

void decache_vcpus_on_cpu(int cpu)
{
}

int kvm_arch_hardware_setup(void)
{
	return 0;
}

void kvm_arch_hardware_unsetup(void)
{
}

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)
{
	return 0;
}

/* 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) {
	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;
	}
	default:
		r = -EINVAL;
	}

	return r;
}

struct kvm *kvm_arch_create_vm(void)
{
	struct kvm *kvm;
	int rc;
	char debug_name[16];

	rc = s390_enable_sie();
	if (rc)
		goto out_nokvm;

	rc = -ENOMEM;
	kvm = kzalloc(sizeof(struct kvm), GFP_KERNEL);
	if (!kvm)
		goto out_nokvm;

	kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
	if (!kvm->arch.sca)
		goto out_nosca;

	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;

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

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

	try_module_get(THIS_MODULE);

	return kvm;
out_nodbf:
	free_page((unsigned long)(kvm->arch.sca));
out_nosca:
	kfree(kvm);
out_nokvm:
	return ERR_PTR(rc);
}

void kvm_arch_destroy_vm(struct kvm *kvm)
{
	debug_unregister(kvm->arch.dbf);
	free_page((unsigned long)(kvm->arch.sca));
	kfree(kvm);
	module_put(THIS_MODULE);
}

/* Section: vcpu related */
int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
{
	return 0;
}

void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
{
	/* kvm common code refers to this, but does'nt call it */
	BUG();
}

void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
{
	save_fp_regs(&vcpu->arch.host_fpregs);
	save_access_regs(vcpu->arch.host_acrs);
	vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
	restore_fp_regs(&vcpu->arch.guest_fpregs);
	restore_access_regs(vcpu->arch.guest_acrs);
}

void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
{
	save_fp_regs(&vcpu->arch.guest_fpregs);
	save_access_regs(vcpu->arch.guest_acrs);
	restore_fp_regs(&vcpu->arch.host_fpregs);
	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;
	vcpu->arch.sie_block->prefix    = 0UL;
	vcpu->arch.sie_block->ihcpu     = 0xffff;
	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;
}

int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
{
	atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH);
	vcpu->arch.sie_block->gmslm = 0xffffffffffUL;
	vcpu->arch.sie_block->gmsor = 0x000000000000;
	vcpu->arch.sie_block->ecb   = 2;
	vcpu->arch.sie_block->eca   = 0xC1002001U;
	setup_timer(&vcpu->arch.ckc_timer, kvm_s390_idle_wakeup,
		 (unsigned long) vcpu);
	get_cpu_id(&vcpu->arch.cpu_id);
	vcpu->arch.cpu_id.version = 0xfe;
	return 0;
}

struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
				      unsigned int id)
{
	struct kvm_vcpu *vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
	int rc = -ENOMEM;

	if (!vcpu)
		goto out_nomem;

	vcpu->arch.sie_block = (struct sie_block *) get_zeroed_page(GFP_KERNEL);

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

	vcpu->arch.sie_block->icpua = id;
	BUG_ON(!kvm->arch.sca);
	BUG_ON(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;

	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;
	spin_lock_bh(&kvm->arch.float_int.lock);
	kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
	init_waitqueue_head(&vcpu->arch.local_int.wq);
	vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
	spin_unlock_bh(&kvm->arch.float_int.lock);

	rc = kvm_vcpu_init(vcpu, kvm, id);
	if (rc)
		goto out_free_cpu;
	VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
		 vcpu->arch.sie_block);

	try_module_get(THIS_MODULE);

	return vcpu;
out_free_cpu:
	kfree(vcpu);
out_nomem:
	return ERR_PTR(rc);
}

void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
{
	VCPU_EVENT(vcpu, 3, "%s", "destroy cpu");
	free_page((unsigned long)(vcpu->arch.sie_block));
	kfree(vcpu);
	module_put(THIS_MODULE);
}

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

static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
{
	vcpu_load(vcpu);
	kvm_s390_vcpu_initial_reset(vcpu);
	vcpu_put(vcpu);
	return 0;
}

int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
{
	vcpu_load(vcpu);
	memcpy(&vcpu->arch.guest_gprs, &regs->gprs, sizeof(regs->gprs));
	vcpu_put(vcpu);
	return 0;
}

int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
{
	vcpu_load(vcpu);
	memcpy(&regs->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs));
	vcpu_put(vcpu);
	return 0;
}

int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs)
{
	vcpu_load(vcpu);
	memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs));
	memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
	vcpu_put(vcpu);
	return 0;
}

int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs)
{
	vcpu_load(vcpu);
	memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs));
	memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
	vcpu_put(vcpu);
	return 0;
}

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

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

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

	vcpu_load(vcpu);
	if (atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_RUNNING)
		rc = -EBUSY;
	else
		vcpu->arch.sie_block->gpsw = psw;
	vcpu_put(vcpu);
	return rc;
}

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

int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
				    struct kvm_debug_guest *dbg)
{
	return -EINVAL; /* not implemented yet */
}

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 */
}

static void __vcpu_run(struct kvm_vcpu *vcpu)
{
	memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16);

	if (need_resched())
		schedule();

	vcpu->arch.sie_block->icptcode = 0;
	local_irq_disable();
	kvm_guest_enter();
	local_irq_enable();
	VCPU_EVENT(vcpu, 6, "entering sie flags %x",
		   atomic_read(&vcpu->arch.sie_block->cpuflags));
	sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs);
	VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
		   vcpu->arch.sie_block->icptcode);
	local_irq_disable();
	kvm_guest_exit();
	local_irq_enable();

	memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16);
}

int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
{
	int rc;
	sigset_t sigsaved;

	vcpu_load(vcpu);

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

	atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);

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

	switch (kvm_run->exit_reason) {
	case KVM_EXIT_S390_SIEIC:
		vcpu->arch.sie_block->gpsw.mask = kvm_run->s390_sieic.mask;
		vcpu->arch.sie_block->gpsw.addr = kvm_run->s390_sieic.addr;
		break;
	case KVM_EXIT_UNKNOWN:
	case KVM_EXIT_S390_RESET:
		break;
	default:
		BUG();
	}

	might_sleep();

	do {
		kvm_s390_deliver_pending_interrupts(vcpu);
		__vcpu_run(vcpu);
		rc = kvm_handle_sie_intercept(vcpu);
	} while (!signal_pending(current) && !rc);

	if (signal_pending(current) && !rc)
		rc = -EINTR;

	if (rc == -ENOTSUPP) {
		/* 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.mask     = vcpu->arch.sie_block->gpsw.mask;
		kvm_run->s390_sieic.addr     = vcpu->arch.sie_block->gpsw.addr;
		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;
	}

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

	vcpu_put(vcpu);

	vcpu->stat.exit_userspace++;
	return rc;
}

static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, const void *from,
		       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
 */
int __kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
{
	const unsigned char archmode = 1;
	int prefix;

	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;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, fp_regs),
			vcpu->arch.guest_fpregs.fprs, 128, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, gp_regs),
			vcpu->arch.guest_gprs, 128, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, psw),
			&vcpu->arch.sie_block->gpsw, 16, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, pref_reg),
			&vcpu->arch.sie_block->prefix, 4, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu,
			addr + offsetof(struct save_area_s390x, fp_ctrl_reg),
			&vcpu->arch.guest_fpregs.fpc, 4, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, tod_reg),
			&vcpu->arch.sie_block->todpr, 4, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, timer),
			&vcpu->arch.sie_block->cputm, 8, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, clk_cmp),
			&vcpu->arch.sie_block->ckc, 8, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, acc_regs),
			&vcpu->arch.guest_acrs, 64, prefix))
		return -EFAULT;

	if (__guestcopy(vcpu,
			addr + offsetof(struct save_area_s390x, ctrl_regs),
			&vcpu->arch.sie_block->gcr, 128, prefix))
		return -EFAULT;
	return 0;
}

static int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
{
	int rc;

	vcpu_load(vcpu);
	rc = __kvm_s390_vcpu_store_status(vcpu, addr);
	vcpu_put(vcpu);
	return rc;
}

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;

	switch (ioctl) {
	case KVM_S390_INTERRUPT: {
		struct kvm_s390_interrupt s390int;

		if (copy_from_user(&s390int, argp, sizeof(s390int)))
			return -EFAULT;
		return kvm_s390_inject_vcpu(vcpu, &s390int);
	}
	case KVM_S390_STORE_STATUS:
		return kvm_s390_vcpu_store_status(vcpu, arg);
	case KVM_S390_SET_INITIAL_PSW: {
		psw_t psw;

		if (copy_from_user(&psw, argp, sizeof(psw)))
			return -EFAULT;
		return kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
	}
	case KVM_S390_INITIAL_RESET:
		return kvm_arch_vcpu_ioctl_initial_reset(vcpu);
	default:
		;
	}
	return -EINVAL;
}

/* Section: memory related */
int kvm_arch_set_memory_region(struct kvm *kvm,
				struct kvm_userspace_memory_region *mem,
				struct kvm_memory_slot old,
				int user_alloc)
{
	/* A few sanity checks. We can have exactly one memory slot which has
	   to start at guest virtual zero and which has to be located at a
	   page boundary in userland and which has to end at a page boundary.
	   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 */

	if (mem->slot)
		return -EINVAL;

	if (mem->guest_phys_addr)
		return -EINVAL;

	if (mem->userspace_addr & (PAGE_SIZE - 1))
		return -EINVAL;

	if (mem->memory_size & (PAGE_SIZE - 1))
		return -EINVAL;

	kvm->arch.guest_origin = mem->userspace_addr;
	kvm->arch.guest_memsize = mem->memory_size;

	/* FIXME: we do want to interrupt running CPUs and update their memory
	   configuration now to avoid race conditions. But hey, changing the
	   memory layout while virtual CPUs are running is usually bad
	   programming practice. */

	return 0;
}

gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn)
{
	return gfn;
}

static int __init kvm_s390_init(void)
{
	return kvm_init(NULL, sizeof(struct kvm_vcpu), THIS_MODULE);
}

static void __exit kvm_s390_exit(void)
{
	kvm_exit();
}

module_init(kvm_s390_init);
module_exit(kvm_s390_exit);
Commit	Line	Data
b0c632db HC	1	/*
	2	* s390host.c -- hosting zSeries kernel virtual machines
	3	*
	4	* Copyright IBM Corp. 2008
	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	*/
	14
	15	#include <linux/compiler.h>
	16	#include <linux/err.h>
	17	#include <linux/fs.h>
	18	#include <linux/init.h>
	19	#include <linux/kvm.h>
	20	#include <linux/kvm_host.h>
	21	#include <linux/module.h>
	22	#include <linux/slab.h>
ba5c1e9b	23	#include <linux/timer.h>
b0c632db HC	24	#include <asm/lowcore.h>
	25	#include <asm/pgtable.h>
	26
8f2abe6a	27	#include "kvm-s390.h"
b0c632db HC	28	#include "gaccess.h"
	29
	30	#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
	31
	32	struct kvm_stats_debugfs_item debugfs_entries[] = {
	33	{ "userspace_handled", VCPU_STAT(exit_userspace) },
0eaeafa1	34	{ "exit_null", VCPU_STAT(exit_null) },
8f2abe6a CB	35	{ "exit_validity", VCPU_STAT(exit_validity) },
	36	{ "exit_stop_request", VCPU_STAT(exit_stop_request) },
	37	{ "exit_external_request", VCPU_STAT(exit_external_request) },
	38	{ "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
ba5c1e9b CO	39	{ "exit_instruction", VCPU_STAT(exit_instruction) },
	40	{ "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
	41	{ "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
	42	{ "instruction_lctg", VCPU_STAT(instruction_lctg) },
	43	{ "instruction_lctl", VCPU_STAT(instruction_lctl) },
	44	{ "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
	45	{ "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
	46	{ "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
	47	{ "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
	48	{ "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
	49	{ "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
	50	{ "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
	51	{ "exit_wait_state", VCPU_STAT(exit_wait_state) },
453423dc CB	52	{ "instruction_stidp", VCPU_STAT(instruction_stidp) },
	53	{ "instruction_spx", VCPU_STAT(instruction_spx) },
	54	{ "instruction_stpx", VCPU_STAT(instruction_stpx) },
	55	{ "instruction_stap", VCPU_STAT(instruction_stap) },
	56	{ "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
	57	{ "instruction_stsch", VCPU_STAT(instruction_stsch) },
	58	{ "instruction_chsc", VCPU_STAT(instruction_chsc) },
	59	{ "instruction_stsi", VCPU_STAT(instruction_stsi) },
	60	{ "instruction_stfl", VCPU_STAT(instruction_stfl) },
5288fbf0 CB	61	{ "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
	62	{ "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
	63	{ "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
	64	{ "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
	65	{ "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
	66	{ "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
e28acfea	67	{ "diagnose_44", VCPU_STAT(diagnose_44) },
b0c632db HC	68	{ NULL }
	69	};
	70
	71
	72	/* Section: not file related */
	73	void kvm_arch_hardware_enable(void *garbage)
	74	{
	75	/* every s390 is virtualization enabled ;-) */
	76	}
	77
	78	void kvm_arch_hardware_disable(void *garbage)
	79	{
	80	}
	81
	82	void decache_vcpus_on_cpu(int cpu)
	83	{
	84	}
	85
	86	int kvm_arch_hardware_setup(void)
	87	{
	88	return 0;
	89	}
	90
	91	void kvm_arch_hardware_unsetup(void)
	92	{
	93	}
	94
	95	void kvm_arch_check_processor_compat(void *rtn)
	96	{
	97	}
	98
	99	int kvm_arch_init(void *opaque)
	100	{
	101	return 0;
	102	}
	103
	104	void kvm_arch_exit(void)
	105	{
	106	}
	107
	108	/* Section: device related */
	109	long kvm_arch_dev_ioctl(struct file *filp,
	110	unsigned int ioctl, unsigned long arg)
	111	{
	112	if (ioctl == KVM_S390_ENABLE_SIE)
	113	return s390_enable_sie();
	114	return -EINVAL;
	115	}
	116
	117	int kvm_dev_ioctl_check_extension(long ext)
	118	{
	119	return 0;
	120	}
	121
	122	/* Section: vm related */
	123	/*
	124	* Get (and clear) the dirty memory log for a memory slot.
	125	*/
	126	int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
	127	struct kvm_dirty_log *log)
	128	{
	129	return 0;
	130	}
	131
132	long kvm_arch_vm_ioctl(struct file *filp,
133	unsigned int ioctl, unsigned long arg)
134	{
135	struct kvm *kvm = filp->private_data;
136	void __user argp = (void __user )arg;
137	int r;
138
139	switch (ioctl) {
ba5c1e9b CO	140	case KVM_S390_INTERRUPT: {
	141	struct kvm_s390_interrupt s390int;
	142
	143	r = -EFAULT;
	144	if (copy_from_user(&s390int, argp, sizeof(s390int)))
	145	break;
	146	r = kvm_s390_inject_vm(kvm, &s390int);
	147	break;
	148	}
b0c632db HC	149	default:
	150	r = -EINVAL;
	151	}
	152
	153	return r;
	154	}
	155
	156	struct kvm *kvm_arch_create_vm(void)
	157	{
	158	struct kvm *kvm;
	159	int rc;
	160	char debug_name[16];
	161
	162	rc = s390_enable_sie();
	163	if (rc)
	164	goto out_nokvm;
	165
	166	rc = -ENOMEM;
	167	kvm = kzalloc(sizeof(struct kvm), GFP_KERNEL);
	168	if (!kvm)
	169	goto out_nokvm;
	170
	171	kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
	172	if (!kvm->arch.sca)
	173	goto out_nosca;
	174
	175	sprintf(debug_name, "kvm-%u", current->pid);
	176
	177	kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
	178	if (!kvm->arch.dbf)
	179	goto out_nodbf;
	180
ba5c1e9b CO	181	spin_lock_init(&kvm->arch.float_int.lock);
	182	INIT_LIST_HEAD(&kvm->arch.float_int.list);
	183
b0c632db HC	184	debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
	185	VM_EVENT(kvm, 3, "%s", "vm created");
	186
	187	try_module_get(THIS_MODULE);
	188
	189	return kvm;
	190	out_nodbf:
	191	free_page((unsigned long)(kvm->arch.sca));
	192	out_nosca:
	193	kfree(kvm);
	194	out_nokvm:
	195	return ERR_PTR(rc);
	196	}
	197
	198	void kvm_arch_destroy_vm(struct kvm *kvm)
	199	{
	200	debug_unregister(kvm->arch.dbf);
	201	free_page((unsigned long)(kvm->arch.sca));
	202	kfree(kvm);
	203	module_put(THIS_MODULE);
	204	}
	205
	206	/* Section: vcpu related */
	207	int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
	208	{
	209	return 0;
	210	}
	211
	212	void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
	213	{
	214	/* kvm common code refers to this, but does'nt call it */
	215	BUG();
	216	}
	217
	218	void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
	219	{
	220	save_fp_regs(&vcpu->arch.host_fpregs);
	221	save_access_regs(vcpu->arch.host_acrs);
	222	vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
	223	restore_fp_regs(&vcpu->arch.guest_fpregs);
	224	restore_access_regs(vcpu->arch.guest_acrs);
b0c632db HC	225	}
	226
	227	void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
	228	{
	229	save_fp_regs(&vcpu->arch.guest_fpregs);
	230	save_access_regs(vcpu->arch.guest_acrs);
	231	restore_fp_regs(&vcpu->arch.host_fpregs);
	232	restore_access_regs(vcpu->arch.host_acrs);
	233	}
	234
	235	static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
	236	{
	237	/* this equals initial cpu reset in pop, but we don't switch to ESA */
	238	vcpu->arch.sie_block->gpsw.mask = 0UL;
	239	vcpu->arch.sie_block->gpsw.addr = 0UL;
	240	vcpu->arch.sie_block->prefix = 0UL;
	241	vcpu->arch.sie_block->ihcpu = 0xffff;
	242	vcpu->arch.sie_block->cputm = 0UL;
	243	vcpu->arch.sie_block->ckc = 0UL;
	244	vcpu->arch.sie_block->todpr = 0;
	245	memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
	246	vcpu->arch.sie_block->gcr[0] = 0xE0UL;
	247	vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
	248	vcpu->arch.guest_fpregs.fpc = 0;
	249	asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
	250	vcpu->arch.sie_block->gbea = 1;
	251	}
	252
	253	int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
	254	{
	255	atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH);
	256	vcpu->arch.sie_block->gmslm = 0xffffffffffUL;
	257	vcpu->arch.sie_block->gmsor = 0x000000000000;
	258	vcpu->arch.sie_block->ecb = 2;
	259	vcpu->arch.sie_block->eca = 0xC1002001U;
ba5c1e9b CO	260	setup_timer(&vcpu->arch.ckc_timer, kvm_s390_idle_wakeup,
ba5c1e9b CO	261	(unsigned long) vcpu);
453423dc CB	262	get_cpu_id(&vcpu->arch.cpu_id);
453423dc CB	263	vcpu->arch.cpu_id.version = 0xfe;
b0c632db HC	264	return 0;
	265	}
	266
	267	struct kvm_vcpu kvm_arch_vcpu_create(struct kvm kvm,
	268	unsigned int id)
	269	{
	270	struct kvm_vcpu *vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
	271	int rc = -ENOMEM;
	272
	273	if (!vcpu)
	274	goto out_nomem;
	275
	276	vcpu->arch.sie_block = (struct sie_block *) get_zeroed_page(GFP_KERNEL);
	277
	278	if (!vcpu->arch.sie_block)
	279	goto out_free_cpu;
	280
	281	vcpu->arch.sie_block->icpua = id;
	282	BUG_ON(!kvm->arch.sca);
	283	BUG_ON(kvm->arch.sca->cpu[id].sda);
	284	kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block;
	285	vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32);
	286	vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
	287
ba5c1e9b CO	288	spin_lock_init(&vcpu->arch.local_int.lock);
	289	INIT_LIST_HEAD(&vcpu->arch.local_int.list);
	290	vcpu->arch.local_int.float_int = &kvm->arch.float_int;
	291	spin_lock_bh(&kvm->arch.float_int.lock);
	292	kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
	293	init_waitqueue_head(&vcpu->arch.local_int.wq);
5288fbf0	294	vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
ba5c1e9b CO	295	spin_unlock_bh(&kvm->arch.float_int.lock);
ba5c1e9b CO	296
b0c632db HC	297	rc = kvm_vcpu_init(vcpu, kvm, id);
	298	if (rc)
	299	goto out_free_cpu;
	300	VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
	301	vcpu->arch.sie_block);
	302
	303	try_module_get(THIS_MODULE);
	304
	305	return vcpu;
	306	out_free_cpu:
	307	kfree(vcpu);
	308	out_nomem:
	309	return ERR_PTR(rc);
	310	}
	311
	312	void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
	313	{
	314	VCPU_EVENT(vcpu, 3, "%s", "destroy cpu");
	315	free_page((unsigned long)(vcpu->arch.sie_block));
	316	kfree(vcpu);
	317	module_put(THIS_MODULE);
	318	}
	319
	320	int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
	321	{
	322	/* kvm common code refers to this, but never calls it */
	323	BUG();
	324	return 0;
	325	}
	326
	327	static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
	328	{
	329	vcpu_load(vcpu);
	330	kvm_s390_vcpu_initial_reset(vcpu);
	331	vcpu_put(vcpu);
	332	return 0;
	333	}
	334
	335	int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu vcpu, struct kvm_regs regs)
	336	{
	337	vcpu_load(vcpu);
	338	memcpy(&vcpu->arch.guest_gprs, &regs->gprs, sizeof(regs->gprs));
	339	vcpu_put(vcpu);
	340	return 0;
	341	}
	342
	343	int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu vcpu, struct kvm_regs regs)
	344	{
	345	vcpu_load(vcpu);
	346	memcpy(&regs->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs));
	347	vcpu_put(vcpu);
	348	return 0;
	349	}
	350
	351	int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
	352	struct kvm_sregs *sregs)
	353	{
	354	vcpu_load(vcpu);
	355	memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs));
	356	memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
	357	vcpu_put(vcpu);
	358	return 0;
	359	}
	360
361	int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
362	struct kvm_sregs *sregs)
363	{
364	vcpu_load(vcpu);
365	memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs));
366	memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
367	vcpu_put(vcpu);
368	return 0;
369	}
370
371	int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu vcpu, struct kvm_fpu fpu)
372	{
373	vcpu_load(vcpu);
374	memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
375	vcpu->arch.guest_fpregs.fpc = fpu->fpc;
376	vcpu_put(vcpu);
377	return 0;
378	}
379
380	int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu vcpu, struct kvm_fpu fpu)
381	{
382	vcpu_load(vcpu);
383	memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
384	fpu->fpc = vcpu->arch.guest_fpregs.fpc;
385	vcpu_put(vcpu);
386	return 0;
387	}
388
389	static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
390	{
391	int rc = 0;
392
393	vcpu_load(vcpu);
394	if (atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_RUNNING)
395	rc = -EBUSY;
396	else
397	vcpu->arch.sie_block->gpsw = psw;
398	vcpu_put(vcpu);
399	return rc;
400	}
401
402	int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
403	struct kvm_translation *tr)
404	{
405	return -EINVAL; /* not implemented yet */
406	}
407
408	int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
409	struct kvm_debug_guest *dbg)
410	{
411	return -EINVAL; /* not implemented yet */
412	}
413
62d9f0db MT	414	int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
	415	struct kvm_mp_state *mp_state)
	416	{
	417	return -EINVAL; /* not implemented yet */
	418	}
	419
	420	int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
	421	struct kvm_mp_state *mp_state)
	422	{
	423	return -EINVAL; /* not implemented yet */
	424	}
	425
b0c632db HC	426	static void __vcpu_run(struct kvm_vcpu *vcpu)
	427	{
	428	memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16);
	429
	430	if (need_resched())
	431	schedule();
	432
	433	vcpu->arch.sie_block->icptcode = 0;
	434	local_irq_disable();
	435	kvm_guest_enter();
	436	local_irq_enable();
	437	VCPU_EVENT(vcpu, 6, "entering sie flags %x",
	438	atomic_read(&vcpu->arch.sie_block->cpuflags));
	439	sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs);
	440	VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
	441	vcpu->arch.sie_block->icptcode);
	442	local_irq_disable();
	443	kvm_guest_exit();
	444	local_irq_enable();
	445
	446	memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16);
	447	}
	448
	449	int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu vcpu, struct kvm_run kvm_run)
	450	{
8f2abe6a	451	int rc;
b0c632db HC	452	sigset_t sigsaved;
	453
	454	vcpu_load(vcpu);
	455
	456	if (vcpu->sigset_active)
	457	sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
	458
	459	atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
	460
ba5c1e9b CO	461	BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
ba5c1e9b CO	462
8f2abe6a CB	463	switch (kvm_run->exit_reason) {
	464	case KVM_EXIT_S390_SIEIC:
	465	vcpu->arch.sie_block->gpsw.mask = kvm_run->s390_sieic.mask;
	466	vcpu->arch.sie_block->gpsw.addr = kvm_run->s390_sieic.addr;
	467	break;
	468	case KVM_EXIT_UNKNOWN:
	469	case KVM_EXIT_S390_RESET:
	470	break;
	471	default:
	472	BUG();
	473	}
	474
	475	might_sleep();
	476
	477	do {
ba5c1e9b	478	kvm_s390_deliver_pending_interrupts(vcpu);
8f2abe6a	479	__vcpu_run(vcpu);
8f2abe6a CB	480	rc = kvm_handle_sie_intercept(vcpu);
	481	} while (!signal_pending(current) && !rc);
	482
	483	if (signal_pending(current) && !rc)
	484	rc = -EINTR;
	485
	486	if (rc == -ENOTSUPP) {
	487	/* intercept cannot be handled in-kernel, prepare kvm-run */
	488	kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
	489	kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
	490	kvm_run->s390_sieic.mask = vcpu->arch.sie_block->gpsw.mask;
	491	kvm_run->s390_sieic.addr = vcpu->arch.sie_block->gpsw.addr;
	492	kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
	493	kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
	494	rc = 0;
	495	}
	496
	497	if (rc == -EREMOTE) {
	498	/* intercept was handled, but userspace support is needed
	499	* kvm_run has been prepared by the handler */
	500	rc = 0;
	501	}
b0c632db HC	502
	503	if (vcpu->sigset_active)
	504	sigprocmask(SIG_SETMASK, &sigsaved, NULL);
	505
	506	vcpu_put(vcpu);
	507
	508	vcpu->stat.exit_userspace++;
7e8e6ab4	509	return rc;
b0c632db HC	510	}
	511
	512	static int __guestcopy(struct kvm_vcpu vcpu, u64 guestdest, const void from,
	513	unsigned long n, int prefix)
	514	{
	515	if (prefix)
	516	return copy_to_guest(vcpu, guestdest, from, n);
	517	else
	518	return copy_to_guest_absolute(vcpu, guestdest, from, n);
	519	}
	520
	521	/*
	522	* store status at address
	523	* we use have two special cases:
	524	* KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
	525	* KVM_S390_STORE_STATUS_PREFIXED: -> prefix
	526	*/
	527	int __kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
	528	{
	529	const unsigned char archmode = 1;
	530	int prefix;
	531
	532	if (addr == KVM_S390_STORE_STATUS_NOADDR) {
	533	if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
	534	return -EFAULT;
	535	addr = SAVE_AREA_BASE;
	536	prefix = 0;
	537	} else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
	538	if (copy_to_guest(vcpu, 163ul, &archmode, 1))
	539	return -EFAULT;
	540	addr = SAVE_AREA_BASE;
	541	prefix = 1;
	542	} else
	543	prefix = 0;
	544
	545	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, fp_regs),
	546	vcpu->arch.guest_fpregs.fprs, 128, prefix))
	547	return -EFAULT;
	548
	549	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, gp_regs),
	550	vcpu->arch.guest_gprs, 128, prefix))
	551	return -EFAULT;
	552
	553	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, psw),
	554	&vcpu->arch.sie_block->gpsw, 16, prefix))
	555	return -EFAULT;
	556
	557	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, pref_reg),
	558	&vcpu->arch.sie_block->prefix, 4, prefix))
	559	return -EFAULT;
	560
	561	if (__guestcopy(vcpu,
	562	addr + offsetof(struct save_area_s390x, fp_ctrl_reg),
	563	&vcpu->arch.guest_fpregs.fpc, 4, prefix))
	564	return -EFAULT;
	565
	566	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, tod_reg),
	567	&vcpu->arch.sie_block->todpr, 4, prefix))
	568	return -EFAULT;
	569
	570	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, timer),
	571	&vcpu->arch.sie_block->cputm, 8, prefix))
	572	return -EFAULT;
	573
574	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, clk_cmp),
575	&vcpu->arch.sie_block->ckc, 8, prefix))
576	return -EFAULT;
577
578	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, acc_regs),
579	&vcpu->arch.guest_acrs, 64, prefix))
580	return -EFAULT;
581
582	if (__guestcopy(vcpu,
583	addr + offsetof(struct save_area_s390x, ctrl_regs),
584	&vcpu->arch.sie_block->gcr, 128, prefix))
585	return -EFAULT;
586	return 0;
587	}
588
589	static int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
590	{
591	int rc;
592
593	vcpu_load(vcpu);
594	rc = __kvm_s390_vcpu_store_status(vcpu, addr);
595	vcpu_put(vcpu);
596	return rc;
597	}
598
599	long kvm_arch_vcpu_ioctl(struct file *filp,
600	unsigned int ioctl, unsigned long arg)
601	{
602	struct kvm_vcpu *vcpu = filp->private_data;
603	void __user argp = (void __user )arg;
604
605	switch (ioctl) {
ba5c1e9b CO	606	case KVM_S390_INTERRUPT: {
	607	struct kvm_s390_interrupt s390int;
	608
	609	if (copy_from_user(&s390int, argp, sizeof(s390int)))
	610	return -EFAULT;
	611	return kvm_s390_inject_vcpu(vcpu, &s390int);
	612	}
b0c632db HC	613	case KVM_S390_STORE_STATUS:
	614	return kvm_s390_vcpu_store_status(vcpu, arg);
	615	case KVM_S390_SET_INITIAL_PSW: {
	616	psw_t psw;
	617
	618	if (copy_from_user(&psw, argp, sizeof(psw)))
	619	return -EFAULT;
	620	return kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
	621	}
	622	case KVM_S390_INITIAL_RESET:
	623	return kvm_arch_vcpu_ioctl_initial_reset(vcpu);
	624	default:
	625	;
	626	}
	627	return -EINVAL;
	628	}
	629
	630	/* Section: memory related */
	631	int kvm_arch_set_memory_region(struct kvm *kvm,
	632	struct kvm_userspace_memory_region *mem,
	633	struct kvm_memory_slot old,
	634	int user_alloc)
	635	{
	636	/* A few sanity checks. We can have exactly one memory slot which has
	637	to start at guest virtual zero and which has to be located at a
	638	page boundary in userland and which has to end at a page boundary.
	639	The memory in userland is ok to be fragmented into various different
	640	vmas. It is okay to mmap() and munmap() stuff in this slot after
	641	doing this call at any time */
	642
	643	if (mem->slot)
	644	return -EINVAL;
	645
	646	if (mem->guest_phys_addr)
	647	return -EINVAL;
	648
	649	if (mem->userspace_addr & (PAGE_SIZE - 1))
	650	return -EINVAL;
	651
	652	if (mem->memory_size & (PAGE_SIZE - 1))
	653	return -EINVAL;
	654
	655	kvm->arch.guest_origin = mem->userspace_addr;
	656	kvm->arch.guest_memsize = mem->memory_size;
	657
	658	/* FIXME: we do want to interrupt running CPUs and update their memory
	659	configuration now to avoid race conditions. But hey, changing the
	660	memory layout while virtual CPUs are running is usually bad
	661	programming practice. */
	662
	663	return 0;
	664	}
	665
	666	gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn)
	667	{
	668	return gfn;
	669	}
	670
	671	static int __init kvm_s390_init(void)
	672	{
	673	return kvm_init(NULL, sizeof(struct kvm_vcpu), THIS_MODULE);
	674	}
	675
	676	static void __exit kvm_s390_exit(void)
677	{
678	kvm_exit();
679	}
680
681	module_init(kvm_s390_init);
682	module_exit(kvm_s390_exit);