[deliverable/linux.git] / arch / s390 / kvm / interrupt.c

/*
 * interrupt.c - handling kvm guest interrupts
 *
 * 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>
 */

#include <linux/interrupt.h>
#include <linux/kvm_host.h>
#include <linux/hrtimer.h>
#include <linux/signal.h>
#include <linux/slab.h>
#include <asm/asm-offsets.h>
#include <asm/uaccess.h>
#include "kvm-s390.h"
#include "gaccess.h"

static int psw_extint_disabled(struct kvm_vcpu *vcpu)
{
	return !(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_EXT);
}

static int psw_interrupts_disabled(struct kvm_vcpu *vcpu)
{
	if ((vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PER) ||
	    (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_IO) ||
	    (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_EXT))
		return 0;
	return 1;
}

static int __interrupt_is_deliverable(struct kvm_vcpu *vcpu,
				      struct kvm_s390_interrupt_info *inti)
{
	switch (inti->type) {
	case KVM_S390_INT_EXTERNAL_CALL:
		if (psw_extint_disabled(vcpu))
			return 0;
		if (vcpu->arch.sie_block->gcr[0] & 0x2000ul)
			return 1;
	case KVM_S390_INT_EMERGENCY:
		if (psw_extint_disabled(vcpu))
			return 0;
		if (vcpu->arch.sie_block->gcr[0] & 0x4000ul)
			return 1;
		return 0;
	case KVM_S390_INT_SERVICE:
		if (psw_extint_disabled(vcpu))
			return 0;
		if (vcpu->arch.sie_block->gcr[0] & 0x200ul)
			return 1;
		return 0;
	case KVM_S390_INT_VIRTIO:
		if (psw_extint_disabled(vcpu))
			return 0;
		if (vcpu->arch.sie_block->gcr[0] & 0x200ul)
			return 1;
		return 0;
	case KVM_S390_PROGRAM_INT:
	case KVM_S390_SIGP_STOP:
	case KVM_S390_SIGP_SET_PREFIX:
	case KVM_S390_RESTART:
		return 1;
	default:
		BUG();
	}
	return 0;
}

static void __set_cpu_idle(struct kvm_vcpu *vcpu)
{
	BUG_ON(vcpu->vcpu_id > KVM_MAX_VCPUS - 1);
	atomic_set_mask(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags);
	set_bit(vcpu->vcpu_id, vcpu->arch.local_int.float_int->idle_mask);
}

static void __unset_cpu_idle(struct kvm_vcpu *vcpu)
{
	BUG_ON(vcpu->vcpu_id > KVM_MAX_VCPUS - 1);
	atomic_clear_mask(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags);
	clear_bit(vcpu->vcpu_id, vcpu->arch.local_int.float_int->idle_mask);
}

static void __reset_intercept_indicators(struct kvm_vcpu *vcpu)
{
	atomic_clear_mask(CPUSTAT_ECALL_PEND |
		CPUSTAT_IO_INT | CPUSTAT_EXT_INT | CPUSTAT_STOP_INT,
		&vcpu->arch.sie_block->cpuflags);
	vcpu->arch.sie_block->lctl = 0x0000;
}

static void __set_cpuflag(struct kvm_vcpu *vcpu, u32 flag)
{
	atomic_set_mask(flag, &vcpu->arch.sie_block->cpuflags);
}

static void __set_intercept_indicator(struct kvm_vcpu *vcpu,
				      struct kvm_s390_interrupt_info *inti)
{
	switch (inti->type) {
	case KVM_S390_INT_EXTERNAL_CALL:
	case KVM_S390_INT_EMERGENCY:
	case KVM_S390_INT_SERVICE:
	case KVM_S390_INT_VIRTIO:
		if (psw_extint_disabled(vcpu))
			__set_cpuflag(vcpu, CPUSTAT_EXT_INT);
		else
			vcpu->arch.sie_block->lctl |= LCTL_CR0;
		break;
	case KVM_S390_SIGP_STOP:
		__set_cpuflag(vcpu, CPUSTAT_STOP_INT);
		break;
	default:
		BUG();
	}
}

static void __do_deliver_interrupt(struct kvm_vcpu *vcpu,
				   struct kvm_s390_interrupt_info *inti)
{
	const unsigned short table[] = { 2, 4, 4, 6 };
	int rc, exception = 0;

	switch (inti->type) {
	case KVM_S390_INT_EMERGENCY:
		VCPU_EVENT(vcpu, 4, "%s", "interrupt: sigp emerg");
		vcpu->stat.deliver_emergency_signal++;
		rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x1201);
		if (rc == -EFAULT)
			exception = 1;

		rc = put_guest_u16(vcpu, __LC_EXT_CPU_ADDR, inti->emerg.code);
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
			 &vcpu->arch.sie_block->gpsw, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
			__LC_EXT_NEW_PSW, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;
		break;

	case KVM_S390_INT_EXTERNAL_CALL:
		VCPU_EVENT(vcpu, 4, "%s", "interrupt: sigp ext call");
		vcpu->stat.deliver_external_call++;
		rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x1202);
		if (rc == -EFAULT)
			exception = 1;

		rc = put_guest_u16(vcpu, __LC_EXT_CPU_ADDR, inti->extcall.code);
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
			 &vcpu->arch.sie_block->gpsw, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
			__LC_EXT_NEW_PSW, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;
		break;

	case KVM_S390_INT_SERVICE:
		VCPU_EVENT(vcpu, 4, "interrupt: sclp parm:%x",
			   inti->ext.ext_params);
		vcpu->stat.deliver_service_signal++;
		rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x2401);
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
			 &vcpu->arch.sie_block->gpsw, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
			__LC_EXT_NEW_PSW, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;

		rc = put_guest_u32(vcpu, __LC_EXT_PARAMS, inti->ext.ext_params);
		if (rc == -EFAULT)
			exception = 1;
		break;

	case KVM_S390_INT_VIRTIO:
		VCPU_EVENT(vcpu, 4, "interrupt: virtio parm:%x,parm64:%llx",
			   inti->ext.ext_params, inti->ext.ext_params2);
		vcpu->stat.deliver_virtio_interrupt++;
		rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x2603);
		if (rc == -EFAULT)
			exception = 1;

		rc = put_guest_u16(vcpu, __LC_EXT_CPU_ADDR, 0x0d00);
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
			 &vcpu->arch.sie_block->gpsw, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
			__LC_EXT_NEW_PSW, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;

		rc = put_guest_u32(vcpu, __LC_EXT_PARAMS, inti->ext.ext_params);
		if (rc == -EFAULT)
			exception = 1;

		rc = put_guest_u64(vcpu, __LC_EXT_PARAMS2,
				   inti->ext.ext_params2);
		if (rc == -EFAULT)
			exception = 1;
		break;

	case KVM_S390_SIGP_STOP:
		VCPU_EVENT(vcpu, 4, "%s", "interrupt: cpu stop");
		vcpu->stat.deliver_stop_signal++;
		__set_intercept_indicator(vcpu, inti);
		break;

	case KVM_S390_SIGP_SET_PREFIX:
		VCPU_EVENT(vcpu, 4, "interrupt: set prefix to %x",
			   inti->prefix.address);
		vcpu->stat.deliver_prefix_signal++;
		kvm_s390_set_prefix(vcpu, inti->prefix.address);
		break;

	case KVM_S390_RESTART:
		VCPU_EVENT(vcpu, 4, "%s", "interrupt: cpu restart");
		vcpu->stat.deliver_restart_signal++;
		rc = copy_to_guest(vcpu, offsetof(struct _lowcore,
		  restart_old_psw), &vcpu->arch.sie_block->gpsw, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
			offsetof(struct _lowcore, restart_psw), sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;
		atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
		break;

	case KVM_S390_PROGRAM_INT:
		VCPU_EVENT(vcpu, 4, "interrupt: pgm check code:%x, ilc:%x",
			   inti->pgm.code,
			   table[vcpu->arch.sie_block->ipa >> 14]);
		vcpu->stat.deliver_program_int++;
		rc = put_guest_u16(vcpu, __LC_PGM_INT_CODE, inti->pgm.code);
		if (rc == -EFAULT)
			exception = 1;

		rc = put_guest_u16(vcpu, __LC_PGM_ILC,
			table[vcpu->arch.sie_block->ipa >> 14]);
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_to_guest(vcpu, __LC_PGM_OLD_PSW,
			 &vcpu->arch.sie_block->gpsw, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;

		rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
			__LC_PGM_NEW_PSW, sizeof(psw_t));
		if (rc == -EFAULT)
			exception = 1;
		break;

	default:
		BUG();
	}
	if (exception) {
		printk("kvm: The guest lowcore is not mapped during interrupt "
			"delivery, killing userspace\n");
		do_exit(SIGKILL);
	}
}

static int __try_deliver_ckc_interrupt(struct kvm_vcpu *vcpu)
{
	int rc, exception = 0;

	if (psw_extint_disabled(vcpu))
		return 0;
	if (!(vcpu->arch.sie_block->gcr[0] & 0x800ul))
		return 0;
	rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x1004);
	if (rc == -EFAULT)
		exception = 1;
	rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
		 &vcpu->arch.sie_block->gpsw, sizeof(psw_t));
	if (rc == -EFAULT)
		exception = 1;
	rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
		__LC_EXT_NEW_PSW, sizeof(psw_t));
	if (rc == -EFAULT)
		exception = 1;
	if (exception) {
		printk("kvm: The guest lowcore is not mapped during interrupt "
			"delivery, killing userspace\n");
		do_exit(SIGKILL);
	}
	return 1;
}

static int kvm_cpu_has_interrupt(struct kvm_vcpu *vcpu)
{
	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
	struct kvm_s390_float_interrupt *fi = vcpu->arch.local_int.float_int;
	struct kvm_s390_interrupt_info  *inti;
	int rc = 0;

	if (atomic_read(&li->active)) {
		spin_lock_bh(&li->lock);
		list_for_each_entry(inti, &li->list, list)
			if (__interrupt_is_deliverable(vcpu, inti)) {
				rc = 1;
				break;
			}
		spin_unlock_bh(&li->lock);
	}

	if ((!rc) && atomic_read(&fi->active)) {
		spin_lock(&fi->lock);
		list_for_each_entry(inti, &fi->list, list)
			if (__interrupt_is_deliverable(vcpu, inti)) {
				rc = 1;
				break;
			}
		spin_unlock(&fi->lock);
	}

	if ((!rc) && (vcpu->arch.sie_block->ckc <
		get_clock() + vcpu->arch.sie_block->epoch)) {
		if ((!psw_extint_disabled(vcpu)) &&
			(vcpu->arch.sie_block->gcr[0] & 0x800ul))
			rc = 1;
	}

	return rc;
}

int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
{
	return 0;
}

int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)
{
	u64 now, sltime;
	DECLARE_WAITQUEUE(wait, current);

	vcpu->stat.exit_wait_state++;
	if (kvm_cpu_has_interrupt(vcpu))
		return 0;

	__set_cpu_idle(vcpu);
	spin_lock_bh(&vcpu->arch.local_int.lock);
	vcpu->arch.local_int.timer_due = 0;
	spin_unlock_bh(&vcpu->arch.local_int.lock);

	if (psw_interrupts_disabled(vcpu)) {
		VCPU_EVENT(vcpu, 3, "%s", "disabled wait");
		__unset_cpu_idle(vcpu);
		return -EOPNOTSUPP; /* disabled wait */
	}

	if (psw_extint_disabled(vcpu) ||
	    (!(vcpu->arch.sie_block->gcr[0] & 0x800ul))) {
		VCPU_EVENT(vcpu, 3, "%s", "enabled wait w/o timer");
		goto no_timer;
	}

	now = get_clock() + vcpu->arch.sie_block->epoch;
	if (vcpu->arch.sie_block->ckc < now) {
		__unset_cpu_idle(vcpu);
		return 0;
	}

	sltime = ((vcpu->arch.sie_block->ckc - now)*125)>>9;

	hrtimer_start(&vcpu->arch.ckc_timer, ktime_set (0, sltime) , HRTIMER_MODE_REL);
	VCPU_EVENT(vcpu, 5, "enabled wait via clock comparator: %llx ns", sltime);
no_timer:
	spin_lock(&vcpu->arch.local_int.float_int->lock);
	spin_lock_bh(&vcpu->arch.local_int.lock);
	add_wait_queue(&vcpu->arch.local_int.wq, &wait);
	while (list_empty(&vcpu->arch.local_int.list) &&
		list_empty(&vcpu->arch.local_int.float_int->list) &&
		(!vcpu->arch.local_int.timer_due) &&
		!signal_pending(current)) {
		set_current_state(TASK_INTERRUPTIBLE);
		spin_unlock_bh(&vcpu->arch.local_int.lock);
		spin_unlock(&vcpu->arch.local_int.float_int->lock);
		vcpu_put(vcpu);
		schedule();
		vcpu_load(vcpu);
		spin_lock(&vcpu->arch.local_int.float_int->lock);
		spin_lock_bh(&vcpu->arch.local_int.lock);
	}
	__unset_cpu_idle(vcpu);
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(&vcpu->arch.local_int.wq, &wait);
	spin_unlock_bh(&vcpu->arch.local_int.lock);
	spin_unlock(&vcpu->arch.local_int.float_int->lock);
	hrtimer_try_to_cancel(&vcpu->arch.ckc_timer);
	return 0;
}

void kvm_s390_tasklet(unsigned long parm)
{
	struct kvm_vcpu *vcpu = (struct kvm_vcpu *) parm;

	spin_lock(&vcpu->arch.local_int.lock);
	vcpu->arch.local_int.timer_due = 1;
	if (waitqueue_active(&vcpu->arch.local_int.wq))
		wake_up_interruptible(&vcpu->arch.local_int.wq);
	spin_unlock(&vcpu->arch.local_int.lock);
}

/*
 * low level hrtimer wake routine. Because this runs in hardirq context
 * we schedule a tasklet to do the real work.
 */
enum hrtimer_restart kvm_s390_idle_wakeup(struct hrtimer *timer)
{
	struct kvm_vcpu *vcpu;

	vcpu = container_of(timer, struct kvm_vcpu, arch.ckc_timer);
	tasklet_schedule(&vcpu->arch.tasklet);

	return HRTIMER_NORESTART;
}

void kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
{
	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
	struct kvm_s390_float_interrupt *fi = vcpu->arch.local_int.float_int;
	struct kvm_s390_interrupt_info  *n, *inti = NULL;
	int deliver;

	__reset_intercept_indicators(vcpu);
	if (atomic_read(&li->active)) {
		do {
			deliver = 0;
			spin_lock_bh(&li->lock);
			list_for_each_entry_safe(inti, n, &li->list, list) {
				if (__interrupt_is_deliverable(vcpu, inti)) {
					list_del(&inti->list);
					deliver = 1;
					break;
				}
				__set_intercept_indicator(vcpu, inti);
			}
			if (list_empty(&li->list))
				atomic_set(&li->active, 0);
			spin_unlock_bh(&li->lock);
			if (deliver) {
				__do_deliver_interrupt(vcpu, inti);
				kfree(inti);
			}
		} while (deliver);
	}

	if ((vcpu->arch.sie_block->ckc <
		get_clock() + vcpu->arch.sie_block->epoch))
		__try_deliver_ckc_interrupt(vcpu);

	if (atomic_read(&fi->active)) {
		do {
			deliver = 0;
			spin_lock(&fi->lock);
			list_for_each_entry_safe(inti, n, &fi->list, list) {
				if (__interrupt_is_deliverable(vcpu, inti)) {
					list_del(&inti->list);
					deliver = 1;
					break;
				}
				__set_intercept_indicator(vcpu, inti);
			}
			if (list_empty(&fi->list))
				atomic_set(&fi->active, 0);
			spin_unlock(&fi->lock);
			if (deliver) {
				__do_deliver_interrupt(vcpu, inti);
				kfree(inti);
			}
		} while (deliver);
	}
}

int kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code)
{
	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
	struct kvm_s390_interrupt_info *inti;

	inti = kzalloc(sizeof(*inti), GFP_KERNEL);
	if (!inti)
		return -ENOMEM;

	inti->type = KVM_S390_PROGRAM_INT;
	inti->pgm.code = code;

	VCPU_EVENT(vcpu, 3, "inject: program check %d (from kernel)", code);
	spin_lock_bh(&li->lock);
	list_add(&inti->list, &li->list);
	atomic_set(&li->active, 1);
	BUG_ON(waitqueue_active(&li->wq));
	spin_unlock_bh(&li->lock);
	return 0;
}

int kvm_s390_inject_vm(struct kvm *kvm,
		       struct kvm_s390_interrupt *s390int)
{
	struct kvm_s390_local_interrupt *li;
	struct kvm_s390_float_interrupt *fi;
	struct kvm_s390_interrupt_info *inti;
	int sigcpu;

	inti = kzalloc(sizeof(*inti), GFP_KERNEL);
	if (!inti)
		return -ENOMEM;

	switch (s390int->type) {
	case KVM_S390_INT_VIRTIO:
		VM_EVENT(kvm, 5, "inject: virtio parm:%x,parm64:%llx",
			 s390int->parm, s390int->parm64);
		inti->type = s390int->type;
		inti->ext.ext_params = s390int->parm;
		inti->ext.ext_params2 = s390int->parm64;
		break;
	case KVM_S390_INT_SERVICE:
		VM_EVENT(kvm, 5, "inject: sclp parm:%x", s390int->parm);
		inti->type = s390int->type;
		inti->ext.ext_params = s390int->parm;
		break;
	case KVM_S390_PROGRAM_INT:
	case KVM_S390_SIGP_STOP:
	case KVM_S390_INT_EXTERNAL_CALL:
	case KVM_S390_INT_EMERGENCY:
	default:
		kfree(inti);
		return -EINVAL;
	}

	mutex_lock(&kvm->lock);
	fi = &kvm->arch.float_int;
	spin_lock(&fi->lock);
	list_add_tail(&inti->list, &fi->list);
	atomic_set(&fi->active, 1);
	sigcpu = find_first_bit(fi->idle_mask, KVM_MAX_VCPUS);
	if (sigcpu == KVM_MAX_VCPUS) {
		do {
			sigcpu = fi->next_rr_cpu++;
			if (sigcpu == KVM_MAX_VCPUS)
				sigcpu = fi->next_rr_cpu = 0;
		} while (fi->local_int[sigcpu] == NULL);
	}
	li = fi->local_int[sigcpu];
	spin_lock_bh(&li->lock);
	atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
	if (waitqueue_active(&li->wq))
		wake_up_interruptible(&li->wq);
	spin_unlock_bh(&li->lock);
	spin_unlock(&fi->lock);
	mutex_unlock(&kvm->lock);
	return 0;
}

int kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu,
			 struct kvm_s390_interrupt *s390int)
{
	struct kvm_s390_local_interrupt *li;
	struct kvm_s390_interrupt_info *inti;

	inti = kzalloc(sizeof(*inti), GFP_KERNEL);
	if (!inti)
		return -ENOMEM;

	switch (s390int->type) {
	case KVM_S390_PROGRAM_INT:
		if (s390int->parm & 0xffff0000) {
			kfree(inti);
			return -EINVAL;
		}
		inti->type = s390int->type;
		inti->pgm.code = s390int->parm;
		VCPU_EVENT(vcpu, 3, "inject: program check %d (from user)",
			   s390int->parm);
		break;
	case KVM_S390_SIGP_SET_PREFIX:
		inti->prefix.address = s390int->parm;
		inti->type = s390int->type;
		VCPU_EVENT(vcpu, 3, "inject: set prefix to %x (from user)",
			   s390int->parm);
		break;
	case KVM_S390_SIGP_STOP:
	case KVM_S390_RESTART:
	case KVM_S390_INT_EXTERNAL_CALL:
	case KVM_S390_INT_EMERGENCY:
		VCPU_EVENT(vcpu, 3, "inject: type %x", s390int->type);
		inti->type = s390int->type;
		break;
	case KVM_S390_INT_VIRTIO:
	case KVM_S390_INT_SERVICE:
	default:
		kfree(inti);
		return -EINVAL;
	}

	mutex_lock(&vcpu->kvm->lock);
	li = &vcpu->arch.local_int;
	spin_lock_bh(&li->lock);
	if (inti->type == KVM_S390_PROGRAM_INT)
		list_add(&inti->list, &li->list);
	else
		list_add_tail(&inti->list, &li->list);
	atomic_set(&li->active, 1);
	if (inti->type == KVM_S390_SIGP_STOP)
		li->action_bits |= ACTION_STOP_ON_STOP;
	atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
	if (waitqueue_active(&li->wq))
		wake_up_interruptible(&vcpu->arch.local_int.wq);
	spin_unlock_bh(&li->lock);
	mutex_unlock(&vcpu->kvm->lock);
	return 0;
}
Commit	Line	Data
ba5c1e9b CO	1	/*
	2	* interrupt.c - handling kvm guest interrupts
	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	*/
	12
ca872302	13	#include <linux/interrupt.h>
ba5c1e9b	14	#include <linux/kvm_host.h>
cbb870c8	15	#include <linux/hrtimer.h>
3cd61299	16	#include <linux/signal.h>
5a0e3ad6	17	#include <linux/slab.h>
cbb870c8 HC	18	#include <asm/asm-offsets.h>
cbb870c8 HC	19	#include <asm/uaccess.h>
ba5c1e9b CO	20	#include "kvm-s390.h"
	21	#include "gaccess.h"
	22
	23	static int psw_extint_disabled(struct kvm_vcpu *vcpu)
	24	{
	25	return !(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_EXT);
	26	}
	27
	28	static int psw_interrupts_disabled(struct kvm_vcpu *vcpu)
	29	{
	30	if ((vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PER) \|\|
	31	(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_IO) \|\|
	32	(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_EXT))
	33	return 0;
	34	return 1;
	35	}
	36
	37	static int __interrupt_is_deliverable(struct kvm_vcpu *vcpu,
180c12fb	38	struct kvm_s390_interrupt_info *inti)
ba5c1e9b CO	39	{
ba5c1e9b CO	40	switch (inti->type) {
7697e71f CE	41	case KVM_S390_INT_EXTERNAL_CALL:
	42	if (psw_extint_disabled(vcpu))
	43	return 0;
	44	if (vcpu->arch.sie_block->gcr[0] & 0x2000ul)
	45	return 1;
ba5c1e9b CO	46	case KVM_S390_INT_EMERGENCY:
	47	if (psw_extint_disabled(vcpu))
	48	return 0;
	49	if (vcpu->arch.sie_block->gcr[0] & 0x4000ul)
	50	return 1;
	51	return 0;
	52	case KVM_S390_INT_SERVICE:
	53	if (psw_extint_disabled(vcpu))
	54	return 0;
	55	if (vcpu->arch.sie_block->gcr[0] & 0x200ul)
	56	return 1;
	57	return 0;
	58	case KVM_S390_INT_VIRTIO:
	59	if (psw_extint_disabled(vcpu))
	60	return 0;
	61	if (vcpu->arch.sie_block->gcr[0] & 0x200ul)
	62	return 1;
	63	return 0;
	64	case KVM_S390_PROGRAM_INT:
	65	case KVM_S390_SIGP_STOP:
	66	case KVM_S390_SIGP_SET_PREFIX:
	67	case KVM_S390_RESTART:
	68	return 1;
	69	default:
	70	BUG();
	71	}
	72	return 0;
	73	}
	74
	75	static void __set_cpu_idle(struct kvm_vcpu *vcpu)
	76	{
	77	BUG_ON(vcpu->vcpu_id > KVM_MAX_VCPUS - 1);
	78	atomic_set_mask(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags);
	79	set_bit(vcpu->vcpu_id, vcpu->arch.local_int.float_int->idle_mask);
	80	}
	81
	82	static void __unset_cpu_idle(struct kvm_vcpu *vcpu)
	83	{
	84	BUG_ON(vcpu->vcpu_id > KVM_MAX_VCPUS - 1);
	85	atomic_clear_mask(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags);
	86	clear_bit(vcpu->vcpu_id, vcpu->arch.local_int.float_int->idle_mask);
	87	}
	88
	89	static void __reset_intercept_indicators(struct kvm_vcpu *vcpu)
	90	{
	91	atomic_clear_mask(CPUSTAT_ECALL_PEND \|
	92	CPUSTAT_IO_INT \| CPUSTAT_EXT_INT \| CPUSTAT_STOP_INT,
	93	&vcpu->arch.sie_block->cpuflags);
	94	vcpu->arch.sie_block->lctl = 0x0000;
	95	}
	96
	97	static void __set_cpuflag(struct kvm_vcpu *vcpu, u32 flag)
	98	{
	99	atomic_set_mask(flag, &vcpu->arch.sie_block->cpuflags);
	100	}
	101
	102	static void __set_intercept_indicator(struct kvm_vcpu *vcpu,
180c12fb	103	struct kvm_s390_interrupt_info *inti)
ba5c1e9b CO	104	{
ba5c1e9b CO	105	switch (inti->type) {
7697e71f	106	case KVM_S390_INT_EXTERNAL_CALL:
ba5c1e9b CO	107	case KVM_S390_INT_EMERGENCY:
	108	case KVM_S390_INT_SERVICE:
	109	case KVM_S390_INT_VIRTIO:
	110	if (psw_extint_disabled(vcpu))
	111	__set_cpuflag(vcpu, CPUSTAT_EXT_INT);
	112	else
	113	vcpu->arch.sie_block->lctl \|= LCTL_CR0;
	114	break;
	115	case KVM_S390_SIGP_STOP:
	116	__set_cpuflag(vcpu, CPUSTAT_STOP_INT);
	117	break;
	118	default:
	119	BUG();
	120	}
	121	}
	122
	123	static void __do_deliver_interrupt(struct kvm_vcpu *vcpu,
180c12fb	124	struct kvm_s390_interrupt_info *inti)
ba5c1e9b CO	125	{
	126	const unsigned short table[] = { 2, 4, 4, 6 };
	127	int rc, exception = 0;
	128
	129	switch (inti->type) {
	130	case KVM_S390_INT_EMERGENCY:
	131	VCPU_EVENT(vcpu, 4, "%s", "interrupt: sigp emerg");
	132	vcpu->stat.deliver_emergency_signal++;
	133	rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x1201);
	134	if (rc == -EFAULT)
	135	exception = 1;
	136
7e180bd8	137	rc = put_guest_u16(vcpu, __LC_EXT_CPU_ADDR, inti->emerg.code);
8bb3a2eb CE	138	if (rc == -EFAULT)
	139	exception = 1;
	140
ba5c1e9b CO	141	rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
	142	&vcpu->arch.sie_block->gpsw, sizeof(psw_t));
	143	if (rc == -EFAULT)
	144	exception = 1;
	145
	146	rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
	147	__LC_EXT_NEW_PSW, sizeof(psw_t));
	148	if (rc == -EFAULT)
	149	exception = 1;
	150	break;
	151
7697e71f CE	152	case KVM_S390_INT_EXTERNAL_CALL:
	153	VCPU_EVENT(vcpu, 4, "%s", "interrupt: sigp ext call");
	154	vcpu->stat.deliver_external_call++;
	155	rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x1202);
	156	if (rc == -EFAULT)
	157	exception = 1;
	158
7e180bd8	159	rc = put_guest_u16(vcpu, __LC_EXT_CPU_ADDR, inti->extcall.code);
7697e71f CE	160	if (rc == -EFAULT)
	161	exception = 1;
	162
	163	rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
	164	&vcpu->arch.sie_block->gpsw, sizeof(psw_t));
	165	if (rc == -EFAULT)
	166	exception = 1;
	167
	168	rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
	169	__LC_EXT_NEW_PSW, sizeof(psw_t));
	170	if (rc == -EFAULT)
	171	exception = 1;
	172	break;
	173
ba5c1e9b CO	174	case KVM_S390_INT_SERVICE:
	175	VCPU_EVENT(vcpu, 4, "interrupt: sclp parm:%x",
	176	inti->ext.ext_params);
	177	vcpu->stat.deliver_service_signal++;
	178	rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x2401);
	179	if (rc == -EFAULT)
	180	exception = 1;
	181
	182	rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
	183	&vcpu->arch.sie_block->gpsw, sizeof(psw_t));
	184	if (rc == -EFAULT)
	185	exception = 1;
	186
	187	rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
	188	__LC_EXT_NEW_PSW, sizeof(psw_t));
	189	if (rc == -EFAULT)
	190	exception = 1;
	191
	192	rc = put_guest_u32(vcpu, __LC_EXT_PARAMS, inti->ext.ext_params);
	193	if (rc == -EFAULT)
	194	exception = 1;
	195	break;
	196
	197	case KVM_S390_INT_VIRTIO:
33e19115	198	VCPU_EVENT(vcpu, 4, "interrupt: virtio parm:%x,parm64:%llx",
ba5c1e9b CO	199	inti->ext.ext_params, inti->ext.ext_params2);
	200	vcpu->stat.deliver_virtio_interrupt++;
	201	rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x2603);
	202	if (rc == -EFAULT)
	203	exception = 1;
	204
7e180bd8	205	rc = put_guest_u16(vcpu, __LC_EXT_CPU_ADDR, 0x0d00);
ba5c1e9b CO	206	if (rc == -EFAULT)
	207	exception = 1;
	208
	209	rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
	210	&vcpu->arch.sie_block->gpsw, sizeof(psw_t));
	211	if (rc == -EFAULT)
	212	exception = 1;
	213
	214	rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
	215	__LC_EXT_NEW_PSW, sizeof(psw_t));
	216	if (rc == -EFAULT)
	217	exception = 1;
	218
	219	rc = put_guest_u32(vcpu, __LC_EXT_PARAMS, inti->ext.ext_params);
	220	if (rc == -EFAULT)
	221	exception = 1;
	222
cbb870c8 HC	223	rc = put_guest_u64(vcpu, __LC_EXT_PARAMS2,
cbb870c8 HC	224	inti->ext.ext_params2);
ba5c1e9b CO	225	if (rc == -EFAULT)
	226	exception = 1;
	227	break;
	228
	229	case KVM_S390_SIGP_STOP:
	230	VCPU_EVENT(vcpu, 4, "%s", "interrupt: cpu stop");
	231	vcpu->stat.deliver_stop_signal++;
	232	__set_intercept_indicator(vcpu, inti);
	233	break;
	234
	235	case KVM_S390_SIGP_SET_PREFIX:
	236	VCPU_EVENT(vcpu, 4, "interrupt: set prefix to %x",
	237	inti->prefix.address);
	238	vcpu->stat.deliver_prefix_signal++;
8d26cf7b	239	kvm_s390_set_prefix(vcpu, inti->prefix.address);
ba5c1e9b CO	240	break;
	241
	242	case KVM_S390_RESTART:
	243	VCPU_EVENT(vcpu, 4, "%s", "interrupt: cpu restart");
	244	vcpu->stat.deliver_restart_signal++;
	245	rc = copy_to_guest(vcpu, offsetof(struct _lowcore,
	246	restart_old_psw), &vcpu->arch.sie_block->gpsw, sizeof(psw_t));
	247	if (rc == -EFAULT)
	248	exception = 1;
	249
	250	rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
	251	offsetof(struct _lowcore, restart_psw), sizeof(psw_t));
	252	if (rc == -EFAULT)
	253	exception = 1;
9e6dabef	254	atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
ba5c1e9b CO	255	break;
	256
	257	case KVM_S390_PROGRAM_INT:
	258	VCPU_EVENT(vcpu, 4, "interrupt: pgm check code:%x, ilc:%x",
	259	inti->pgm.code,
	260	table[vcpu->arch.sie_block->ipa >> 14]);
	261	vcpu->stat.deliver_program_int++;
	262	rc = put_guest_u16(vcpu, __LC_PGM_INT_CODE, inti->pgm.code);
	263	if (rc == -EFAULT)
	264	exception = 1;
	265
	266	rc = put_guest_u16(vcpu, __LC_PGM_ILC,
	267	table[vcpu->arch.sie_block->ipa >> 14]);
	268	if (rc == -EFAULT)
	269	exception = 1;
	270
	271	rc = copy_to_guest(vcpu, __LC_PGM_OLD_PSW,
	272	&vcpu->arch.sie_block->gpsw, sizeof(psw_t));
	273	if (rc == -EFAULT)
	274	exception = 1;
	275
	276	rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
	277	__LC_PGM_NEW_PSW, sizeof(psw_t));
	278	if (rc == -EFAULT)
	279	exception = 1;
	280	break;
	281
	282	default:
	283	BUG();
	284	}
ba5c1e9b	285	if (exception) {
3cd61299 CB	286	printk("kvm: The guest lowcore is not mapped during interrupt "
	287	"delivery, killing userspace\n");
	288	do_exit(SIGKILL);
ba5c1e9b CO	289	}
	290	}
	291
	292	static int __try_deliver_ckc_interrupt(struct kvm_vcpu *vcpu)
	293	{
	294	int rc, exception = 0;
	295
	296	if (psw_extint_disabled(vcpu))
	297	return 0;
	298	if (!(vcpu->arch.sie_block->gcr[0] & 0x800ul))
	299	return 0;
	300	rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x1004);
	301	if (rc == -EFAULT)
	302	exception = 1;
	303	rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW,
	304	&vcpu->arch.sie_block->gpsw, sizeof(psw_t));
	305	if (rc == -EFAULT)
	306	exception = 1;
	307	rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw,
	308	__LC_EXT_NEW_PSW, sizeof(psw_t));
	309	if (rc == -EFAULT)
	310	exception = 1;
ba5c1e9b	311	if (exception) {
3cd61299 CB	312	printk("kvm: The guest lowcore is not mapped during interrupt "
	313	"delivery, killing userspace\n");
	314	do_exit(SIGKILL);
ba5c1e9b	315	}
ba5c1e9b CO	316	return 1;
	317	}
	318
a1b37100	319	static int kvm_cpu_has_interrupt(struct kvm_vcpu *vcpu)
ba5c1e9b	320	{
180c12fb CB	321	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
	322	struct kvm_s390_float_interrupt *fi = vcpu->arch.local_int.float_int;
	323	struct kvm_s390_interrupt_info *inti;
ba5c1e9b CO	324	int rc = 0;
	325
	326	if (atomic_read(&li->active)) {
	327	spin_lock_bh(&li->lock);
	328	list_for_each_entry(inti, &li->list, list)
	329	if (__interrupt_is_deliverable(vcpu, inti)) {
	330	rc = 1;
	331	break;
	332	}
	333	spin_unlock_bh(&li->lock);
	334	}
	335
	336	if ((!rc) && atomic_read(&fi->active)) {
b037a4f3	337	spin_lock(&fi->lock);
ba5c1e9b CO	338	list_for_each_entry(inti, &fi->list, list)
	339	if (__interrupt_is_deliverable(vcpu, inti)) {
	340	rc = 1;
	341	break;
	342	}
b037a4f3	343	spin_unlock(&fi->lock);
ba5c1e9b CO	344	}
	345
	346	if ((!rc) && (vcpu->arch.sie_block->ckc <
	347	get_clock() + vcpu->arch.sie_block->epoch)) {
	348	if ((!psw_extint_disabled(vcpu)) &&
	349	(vcpu->arch.sie_block->gcr[0] & 0x800ul))
	350	rc = 1;
	351	}
	352
	353	return rc;
	354	}
	355
3d80840d MT	356	int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
	357	{
	358	return 0;
	359	}
	360
ba5c1e9b CO	361	int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)
	362	{
	363	u64 now, sltime;
	364	DECLARE_WAITQUEUE(wait, current);
	365
	366	vcpu->stat.exit_wait_state++;
	367	if (kvm_cpu_has_interrupt(vcpu))
	368	return 0;
	369
e52b2af5 CO	370	__set_cpu_idle(vcpu);
	371	spin_lock_bh(&vcpu->arch.local_int.lock);
	372	vcpu->arch.local_int.timer_due = 0;
	373	spin_unlock_bh(&vcpu->arch.local_int.lock);
	374
ba5c1e9b CO	375	if (psw_interrupts_disabled(vcpu)) {
	376	VCPU_EVENT(vcpu, 3, "%s", "disabled wait");
	377	__unset_cpu_idle(vcpu);
b8e660b8	378	return -EOPNOTSUPP; /* disabled wait */
ba5c1e9b CO	379	}
	380
	381	if (psw_extint_disabled(vcpu) \|\|
	382	(!(vcpu->arch.sie_block->gcr[0] & 0x800ul))) {
	383	VCPU_EVENT(vcpu, 3, "%s", "enabled wait w/o timer");
	384	goto no_timer;
	385	}
	386
	387	now = get_clock() + vcpu->arch.sie_block->epoch;
	388	if (vcpu->arch.sie_block->ckc < now) {
	389	__unset_cpu_idle(vcpu);
	390	return 0;
	391	}
	392
ca872302	393	sltime = ((vcpu->arch.sie_block->ckc - now)*125)>>9;
ba5c1e9b	394
ca872302 CB	395	hrtimer_start(&vcpu->arch.ckc_timer, ktime_set (0, sltime) , HRTIMER_MODE_REL);
ca872302 CB	396	VCPU_EVENT(vcpu, 5, "enabled wait via clock comparator: %llx ns", sltime);
ba5c1e9b	397	no_timer:
b037a4f3	398	spin_lock(&vcpu->arch.local_int.float_int->lock);
ba5c1e9b	399	spin_lock_bh(&vcpu->arch.local_int.lock);
ba5c1e9b CO	400	add_wait_queue(&vcpu->arch.local_int.wq, &wait);
	401	while (list_empty(&vcpu->arch.local_int.list) &&
	402	list_empty(&vcpu->arch.local_int.float_int->list) &&
	403	(!vcpu->arch.local_int.timer_due) &&
	404	!signal_pending(current)) {
	405	set_current_state(TASK_INTERRUPTIBLE);
	406	spin_unlock_bh(&vcpu->arch.local_int.lock);
b037a4f3	407	spin_unlock(&vcpu->arch.local_int.float_int->lock);
ba5c1e9b CO	408	vcpu_put(vcpu);
	409	schedule();
	410	vcpu_load(vcpu);
b037a4f3	411	spin_lock(&vcpu->arch.local_int.float_int->lock);
ba5c1e9b CO	412	spin_lock_bh(&vcpu->arch.local_int.lock);
	413	}
	414	__unset_cpu_idle(vcpu);
	415	__set_current_state(TASK_RUNNING);
d3bc2f91	416	remove_wait_queue(&vcpu->arch.local_int.wq, &wait);
ba5c1e9b	417	spin_unlock_bh(&vcpu->arch.local_int.lock);
b037a4f3	418	spin_unlock(&vcpu->arch.local_int.float_int->lock);
ca872302	419	hrtimer_try_to_cancel(&vcpu->arch.ckc_timer);
ba5c1e9b CO	420	return 0;
	421	}
	422
ca872302	423	void kvm_s390_tasklet(unsigned long parm)
ba5c1e9b	424	{
ca872302	425	struct kvm_vcpu vcpu = (struct kvm_vcpu ) parm;
ba5c1e9b	426
ca872302	427	spin_lock(&vcpu->arch.local_int.lock);
ba5c1e9b CO	428	vcpu->arch.local_int.timer_due = 1;
	429	if (waitqueue_active(&vcpu->arch.local_int.wq))
	430	wake_up_interruptible(&vcpu->arch.local_int.wq);
ca872302	431	spin_unlock(&vcpu->arch.local_int.lock);
ba5c1e9b CO	432	}
ba5c1e9b CO	433
ca872302 CB	434	/*
	435	* low level hrtimer wake routine. Because this runs in hardirq context
	436	* we schedule a tasklet to do the real work.
	437	*/
	438	enum hrtimer_restart kvm_s390_idle_wakeup(struct hrtimer *timer)
	439	{
	440	struct kvm_vcpu *vcpu;
	441
	442	vcpu = container_of(timer, struct kvm_vcpu, arch.ckc_timer);
	443	tasklet_schedule(&vcpu->arch.tasklet);
	444
	445	return HRTIMER_NORESTART;
	446	}
ba5c1e9b CO	447
	448	void kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
	449	{
180c12fb CB	450	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
	451	struct kvm_s390_float_interrupt *fi = vcpu->arch.local_int.float_int;
	452	struct kvm_s390_interrupt_info n, inti = NULL;
ba5c1e9b CO	453	int deliver;
	454
	455	__reset_intercept_indicators(vcpu);
	456	if (atomic_read(&li->active)) {
	457	do {
	458	deliver = 0;
	459	spin_lock_bh(&li->lock);
	460	list_for_each_entry_safe(inti, n, &li->list, list) {
	461	if (__interrupt_is_deliverable(vcpu, inti)) {
	462	list_del(&inti->list);
	463	deliver = 1;
	464	break;
	465	}
	466	__set_intercept_indicator(vcpu, inti);
	467	}
	468	if (list_empty(&li->list))
	469	atomic_set(&li->active, 0);
	470	spin_unlock_bh(&li->lock);
	471	if (deliver) {
	472	__do_deliver_interrupt(vcpu, inti);
	473	kfree(inti);
	474	}
	475	} while (deliver);
	476	}
	477
	478	if ((vcpu->arch.sie_block->ckc <
	479	get_clock() + vcpu->arch.sie_block->epoch))
	480	__try_deliver_ckc_interrupt(vcpu);
	481
	482	if (atomic_read(&fi->active)) {
	483	do {
	484	deliver = 0;
b037a4f3	485	spin_lock(&fi->lock);
ba5c1e9b CO	486	list_for_each_entry_safe(inti, n, &fi->list, list) {
	487	if (__interrupt_is_deliverable(vcpu, inti)) {
	488	list_del(&inti->list);
	489	deliver = 1;
	490	break;
	491	}
	492	__set_intercept_indicator(vcpu, inti);
	493	}
	494	if (list_empty(&fi->list))
	495	atomic_set(&fi->active, 0);
b037a4f3	496	spin_unlock(&fi->lock);
ba5c1e9b CO	497	if (deliver) {
	498	__do_deliver_interrupt(vcpu, inti);
	499	kfree(inti);
	500	}
	501	} while (deliver);
	502	}
	503	}
	504
	505	int kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code)
	506	{
180c12fb CB	507	struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
180c12fb CB	508	struct kvm_s390_interrupt_info *inti;
ba5c1e9b CO	509
	510	inti = kzalloc(sizeof(*inti), GFP_KERNEL);
	511	if (!inti)
	512	return -ENOMEM;
	513
a419aef8	514	inti->type = KVM_S390_PROGRAM_INT;
ba5c1e9b CO	515	inti->pgm.code = code;
	516
	517	VCPU_EVENT(vcpu, 3, "inject: program check %d (from kernel)", code);
	518	spin_lock_bh(&li->lock);
	519	list_add(&inti->list, &li->list);
	520	atomic_set(&li->active, 1);
	521	BUG_ON(waitqueue_active(&li->wq));
	522	spin_unlock_bh(&li->lock);
	523	return 0;
	524	}
	525
	526	int kvm_s390_inject_vm(struct kvm *kvm,
	527	struct kvm_s390_interrupt *s390int)
	528	{
180c12fb CB	529	struct kvm_s390_local_interrupt *li;
	530	struct kvm_s390_float_interrupt *fi;
	531	struct kvm_s390_interrupt_info *inti;
ba5c1e9b CO	532	int sigcpu;
	533
	534	inti = kzalloc(sizeof(*inti), GFP_KERNEL);
	535	if (!inti)
	536	return -ENOMEM;
	537
	538	switch (s390int->type) {
	539	case KVM_S390_INT_VIRTIO:
33e19115	540	VM_EVENT(kvm, 5, "inject: virtio parm:%x,parm64:%llx",
ba5c1e9b CO	541	s390int->parm, s390int->parm64);
	542	inti->type = s390int->type;
	543	inti->ext.ext_params = s390int->parm;
	544	inti->ext.ext_params2 = s390int->parm64;
	545	break;
	546	case KVM_S390_INT_SERVICE:
	547	VM_EVENT(kvm, 5, "inject: sclp parm:%x", s390int->parm);
	548	inti->type = s390int->type;
	549	inti->ext.ext_params = s390int->parm;
	550	break;
	551	case KVM_S390_PROGRAM_INT:
	552	case KVM_S390_SIGP_STOP:
7697e71f	553	case KVM_S390_INT_EXTERNAL_CALL:
ba5c1e9b CO	554	case KVM_S390_INT_EMERGENCY:
	555	default:
	556	kfree(inti);
	557	return -EINVAL;
	558	}
	559
	560	mutex_lock(&kvm->lock);
	561	fi = &kvm->arch.float_int;
b037a4f3	562	spin_lock(&fi->lock);
ba5c1e9b CO	563	list_add_tail(&inti->list, &fi->list);
	564	atomic_set(&fi->active, 1);
	565	sigcpu = find_first_bit(fi->idle_mask, KVM_MAX_VCPUS);
	566	if (sigcpu == KVM_MAX_VCPUS) {
	567	do {
	568	sigcpu = fi->next_rr_cpu++;
	569	if (sigcpu == KVM_MAX_VCPUS)
	570	sigcpu = fi->next_rr_cpu = 0;
	571	} while (fi->local_int[sigcpu] == NULL);
	572	}
	573	li = fi->local_int[sigcpu];
	574	spin_lock_bh(&li->lock);
	575	atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
	576	if (waitqueue_active(&li->wq))
	577	wake_up_interruptible(&li->wq);
	578	spin_unlock_bh(&li->lock);
b037a4f3	579	spin_unlock(&fi->lock);
ba5c1e9b CO	580	mutex_unlock(&kvm->lock);
	581	return 0;
	582	}
	583
	584	int kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu,
	585	struct kvm_s390_interrupt *s390int)
	586	{
180c12fb CB	587	struct kvm_s390_local_interrupt *li;
180c12fb CB	588	struct kvm_s390_interrupt_info *inti;
ba5c1e9b CO	589
	590	inti = kzalloc(sizeof(*inti), GFP_KERNEL);
	591	if (!inti)
	592	return -ENOMEM;
	593
	594	switch (s390int->type) {
	595	case KVM_S390_PROGRAM_INT:
	596	if (s390int->parm & 0xffff0000) {
	597	kfree(inti);
	598	return -EINVAL;
	599	}
	600	inti->type = s390int->type;
	601	inti->pgm.code = s390int->parm;
	602	VCPU_EVENT(vcpu, 3, "inject: program check %d (from user)",
	603	s390int->parm);
	604	break;
b7e6e4d3 CB	605	case KVM_S390_SIGP_SET_PREFIX:
	606	inti->prefix.address = s390int->parm;
	607	inti->type = s390int->type;
	608	VCPU_EVENT(vcpu, 3, "inject: set prefix to %x (from user)",
	609	s390int->parm);
	610	break;
ba5c1e9b CO	611	case KVM_S390_SIGP_STOP:
ba5c1e9b CO	612	case KVM_S390_RESTART:
7697e71f	613	case KVM_S390_INT_EXTERNAL_CALL:
ba5c1e9b CO	614	case KVM_S390_INT_EMERGENCY:
	615	VCPU_EVENT(vcpu, 3, "inject: type %x", s390int->type);
	616	inti->type = s390int->type;
	617	break;
	618	case KVM_S390_INT_VIRTIO:
	619	case KVM_S390_INT_SERVICE:
	620	default:
	621	kfree(inti);
	622	return -EINVAL;
	623	}
	624
	625	mutex_lock(&vcpu->kvm->lock);
	626	li = &vcpu->arch.local_int;
	627	spin_lock_bh(&li->lock);
	628	if (inti->type == KVM_S390_PROGRAM_INT)
	629	list_add(&inti->list, &li->list);
	630	else
	631	list_add_tail(&inti->list, &li->list);
	632	atomic_set(&li->active, 1);
	633	if (inti->type == KVM_S390_SIGP_STOP)
	634	li->action_bits \|= ACTION_STOP_ON_STOP;
	635	atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
	636	if (waitqueue_active(&li->wq))
	637	wake_up_interruptible(&vcpu->arch.local_int.wq);
	638	spin_unlock_bh(&li->lock);
	639	mutex_unlock(&vcpu->kvm->lock);
	640	return 0;
	641	}