[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_lctlg", VCPU_STAT(instruction_lctlg) },
	{ "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)
{
}

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)
{
	switch (ext) {
	case KVM_CAP_USER_MEMORY:
		return 1;
	default:
		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);
	kvm_free_physmem(kvm);
	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;
}

/* The current code can have up to 256 pages for virtio */
#define VIRTIODESCSPACE (256ul * 4096ul)

int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
{
	atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH);
	vcpu->arch.sie_block->gmslm = vcpu->kvm->arch.guest_memsize +
				      vcpu->kvm->arch.guest_origin +
				      VIRTIODESCSPACE - 1ul;
	vcpu->arch.sie_block->gmsor = vcpu->kvm->arch.guest_origin;
	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 kvm_s390_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 */
}

extern void s390_handle_mcck(void);

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

	if (need_resched())
		schedule();

	if (test_thread_flag(TIF_MCCK_PENDING))
		s390_handle_mcck();

	kvm_s390_deliver_pending_interrupts(vcpu);

	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));
	if (sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs)) {
		VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
		kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
	}
	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 {
		__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;
}

void kvm_arch_flush_shadow(struct kvm *kvm)
{
}

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