[deliverable/linux.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 */
}

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));
	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 {
		__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
71cde587 CB	426	extern void s390_handle_mcck(void);
71cde587 CB	427
b0c632db HC	428	static void __vcpu_run(struct kvm_vcpu *vcpu)
	429	{
	430	memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16);
	431
	432	if (need_resched())
	433	schedule();
	434
71cde587 CB	435	if (test_thread_flag(TIF_MCCK_PENDING))
	436	s390_handle_mcck();
	437
0ff31867 CO	438	kvm_s390_deliver_pending_interrupts(vcpu);
0ff31867 CO	439
b0c632db HC	440	vcpu->arch.sie_block->icptcode = 0;
	441	local_irq_disable();
	442	kvm_guest_enter();
	443	local_irq_enable();
	444	VCPU_EVENT(vcpu, 6, "entering sie flags %x",
	445	atomic_read(&vcpu->arch.sie_block->cpuflags));
	446	sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs);
	447	VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
	448	vcpu->arch.sie_block->icptcode);
	449	local_irq_disable();
	450	kvm_guest_exit();
	451	local_irq_enable();
	452
	453	memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16);
	454	}
	455
	456	int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu vcpu, struct kvm_run kvm_run)
	457	{
8f2abe6a	458	int rc;
b0c632db HC	459	sigset_t sigsaved;
	460
	461	vcpu_load(vcpu);
	462
	463	if (vcpu->sigset_active)
	464	sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
	465
	466	atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
	467
ba5c1e9b CO	468	BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
ba5c1e9b CO	469
8f2abe6a CB	470	switch (kvm_run->exit_reason) {
	471	case KVM_EXIT_S390_SIEIC:
	472	vcpu->arch.sie_block->gpsw.mask = kvm_run->s390_sieic.mask;
	473	vcpu->arch.sie_block->gpsw.addr = kvm_run->s390_sieic.addr;
	474	break;
	475	case KVM_EXIT_UNKNOWN:
	476	case KVM_EXIT_S390_RESET:
	477	break;
	478	default:
	479	BUG();
	480	}
	481
	482	might_sleep();
	483
	484	do {
	485	__vcpu_run(vcpu);
8f2abe6a CB	486	rc = kvm_handle_sie_intercept(vcpu);
	487	} while (!signal_pending(current) && !rc);
	488
	489	if (signal_pending(current) && !rc)
	490	rc = -EINTR;
	491
	492	if (rc == -ENOTSUPP) {
	493	/* intercept cannot be handled in-kernel, prepare kvm-run */
	494	kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
	495	kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
	496	kvm_run->s390_sieic.mask = vcpu->arch.sie_block->gpsw.mask;
	497	kvm_run->s390_sieic.addr = vcpu->arch.sie_block->gpsw.addr;
	498	kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
	499	kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
	500	rc = 0;
	501	}
	502
	503	if (rc == -EREMOTE) {
	504	/* intercept was handled, but userspace support is needed
	505	* kvm_run has been prepared by the handler */
	506	rc = 0;
	507	}
b0c632db HC	508
	509	if (vcpu->sigset_active)
	510	sigprocmask(SIG_SETMASK, &sigsaved, NULL);
	511
	512	vcpu_put(vcpu);
	513
	514	vcpu->stat.exit_userspace++;
7e8e6ab4	515	return rc;
b0c632db HC	516	}
	517
	518	static int __guestcopy(struct kvm_vcpu vcpu, u64 guestdest, const void from,
	519	unsigned long n, int prefix)
	520	{
	521	if (prefix)
	522	return copy_to_guest(vcpu, guestdest, from, n);
	523	else
	524	return copy_to_guest_absolute(vcpu, guestdest, from, n);
	525	}
	526
	527	/*
	528	* store status at address
	529	* we use have two special cases:
	530	* KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
	531	* KVM_S390_STORE_STATUS_PREFIXED: -> prefix
	532	*/
	533	int __kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
	534	{
	535	const unsigned char archmode = 1;
	536	int prefix;
	537
	538	if (addr == KVM_S390_STORE_STATUS_NOADDR) {
	539	if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
	540	return -EFAULT;
	541	addr = SAVE_AREA_BASE;
	542	prefix = 0;
	543	} else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
	544	if (copy_to_guest(vcpu, 163ul, &archmode, 1))
	545	return -EFAULT;
	546	addr = SAVE_AREA_BASE;
	547	prefix = 1;
	548	} else
	549	prefix = 0;
	550
	551	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, fp_regs),
	552	vcpu->arch.guest_fpregs.fprs, 128, prefix))
	553	return -EFAULT;
	554
	555	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, gp_regs),
	556	vcpu->arch.guest_gprs, 128, prefix))
	557	return -EFAULT;
	558
	559	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, psw),
	560	&vcpu->arch.sie_block->gpsw, 16, prefix))
	561	return -EFAULT;
	562
	563	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, pref_reg),
	564	&vcpu->arch.sie_block->prefix, 4, prefix))
	565	return -EFAULT;
	566
	567	if (__guestcopy(vcpu,
	568	addr + offsetof(struct save_area_s390x, fp_ctrl_reg),
	569	&vcpu->arch.guest_fpregs.fpc, 4, prefix))
	570	return -EFAULT;
	571
	572	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, tod_reg),
	573	&vcpu->arch.sie_block->todpr, 4, prefix))
	574	return -EFAULT;
	575
	576	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, timer),
	577	&vcpu->arch.sie_block->cputm, 8, prefix))
	578	return -EFAULT;
	579
580	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, clk_cmp),
581	&vcpu->arch.sie_block->ckc, 8, prefix))
582	return -EFAULT;
583
584	if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, acc_regs),
585	&vcpu->arch.guest_acrs, 64, prefix))
586	return -EFAULT;
587
588	if (__guestcopy(vcpu,
589	addr + offsetof(struct save_area_s390x, ctrl_regs),
590	&vcpu->arch.sie_block->gcr, 128, prefix))
591	return -EFAULT;
592	return 0;
593	}
594
595	static int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
596	{
597	int rc;
598
599	vcpu_load(vcpu);
600	rc = __kvm_s390_vcpu_store_status(vcpu, addr);
601	vcpu_put(vcpu);
602	return rc;
603	}
604
605	long kvm_arch_vcpu_ioctl(struct file *filp,
606	unsigned int ioctl, unsigned long arg)
607	{
608	struct kvm_vcpu *vcpu = filp->private_data;
609	void __user argp = (void __user )arg;
610
611	switch (ioctl) {
ba5c1e9b CO	612	case KVM_S390_INTERRUPT: {
	613	struct kvm_s390_interrupt s390int;
	614
	615	if (copy_from_user(&s390int, argp, sizeof(s390int)))
	616	return -EFAULT;
	617	return kvm_s390_inject_vcpu(vcpu, &s390int);
	618	}
b0c632db HC	619	case KVM_S390_STORE_STATUS:
	620	return kvm_s390_vcpu_store_status(vcpu, arg);
	621	case KVM_S390_SET_INITIAL_PSW: {
	622	psw_t psw;
	623
	624	if (copy_from_user(&psw, argp, sizeof(psw)))
	625	return -EFAULT;
	626	return kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
	627	}
	628	case KVM_S390_INITIAL_RESET:
	629	return kvm_arch_vcpu_ioctl_initial_reset(vcpu);
	630	default:
	631	;
	632	}
	633	return -EINVAL;
	634	}
	635
	636	/* Section: memory related */
	637	int kvm_arch_set_memory_region(struct kvm *kvm,
	638	struct kvm_userspace_memory_region *mem,
	639	struct kvm_memory_slot old,
	640	int user_alloc)
	641	{
	642	/* A few sanity checks. We can have exactly one memory slot which has
	643	to start at guest virtual zero and which has to be located at a
	644	page boundary in userland and which has to end at a page boundary.
	645	The memory in userland is ok to be fragmented into various different
	646	vmas. It is okay to mmap() and munmap() stuff in this slot after
	647	doing this call at any time */
	648
	649	if (mem->slot)
	650	return -EINVAL;
	651
	652	if (mem->guest_phys_addr)
	653	return -EINVAL;
	654
	655	if (mem->userspace_addr & (PAGE_SIZE - 1))
	656	return -EINVAL;
	657
	658	if (mem->memory_size & (PAGE_SIZE - 1))
	659	return -EINVAL;
	660
	661	kvm->arch.guest_origin = mem->userspace_addr;
	662	kvm->arch.guest_memsize = mem->memory_size;
	663
	664	/* FIXME: we do want to interrupt running CPUs and update their memory
	665	configuration now to avoid race conditions. But hey, changing the
	666	memory layout while virtual CPUs are running is usually bad
	667	programming practice. */
	668
	669	return 0;
	670	}
	671
	672	gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn)
	673	{
	674	return gfn;
	675	}
	676
	677	static int __init kvm_s390_init(void)
	678	{
	679	return kvm_init(NULL, sizeof(struct kvm_vcpu), THIS_MODULE);
	680	}
	681
	682	static void __exit kvm_s390_exit(void)
683	{
684	kvm_exit();
685	}
686
687	module_init(kvm_s390_init);
688	module_exit(kvm_s390_exit);