Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c05c4186 authored by Jens Freimann's avatar Jens Freimann Committed by Christian Borntraeger
Browse files

KVM: s390: add floating irq controller 



This patch adds a floating irq controller as a kvm_device.
It will be necessary for migration of floating interrupts as well
as for hardening the reset code by allowing user space to explicitly
remove all pending floating interrupts.

Signed-off-by: default avatarJens Freimann <jfrei@linux.vnet.ibm.com>
Reviewed-by: default avatarCornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: default avatarChristian Borntraeger <borntraeger@de.ibm.com>
parent 81aa8efe

Documentation/virtual/kvm/devices/s390_flic.txt

0 → 100644
+36 −0
Original line number Diff line number Diff line 
FLIC (floating interrupt controller)

====================================



FLIC handles floating (non per-cpu) interrupts, i.e. I/O, service and some

machine check interruptions. All interrupts are stored in a per-vm list of

pending interrupts. FLIC performs operations on this list.



Only one FLIC instance may be instantiated.



FLIC provides support to

- add interrupts (KVM_DEV_FLIC_ENQUEUE)

- inspect currently pending interrupts (KVM_FLIC_GET_ALL_IRQS)

- purge all pending floating interrupts (KVM_DEV_FLIC_CLEAR_IRQS)



Groups:

  KVM_DEV_FLIC_ENQUEUE

    Passes a buffer and length into the kernel which are then injected into

    the list of pending interrupts.

    attr->addr contains the pointer to the buffer and attr->attr contains

    the length of the buffer.

    The format of the data structure kvm_s390_irq as it is copied from userspace

    is defined in usr/include/linux/kvm.h.



  KVM_DEV_FLIC_GET_ALL_IRQS

    Copies all floating interrupts into a buffer provided by userspace.

    When the buffer is too small it returns -ENOMEM, which is the indication

    for userspace to try again with a bigger buffer.

    All interrupts remain pending, i.e. are not deleted from the list of

    currently pending interrupts.

    attr->addr contains the userspace address of the buffer into which all

    interrupt data will be copied.

    attr->attr contains the size of the buffer in bytes.



  KVM_DEV_FLIC_CLEAR_IRQS

    Simply deletes all elements from the list of currently pending floating

    interrupts.  No interrupts are injected into the guest.

arch/s390/include/asm/kvm_host.h

+1 −0
Original line number Diff line number Diff line
@@ -243,6 +243,7 @@ struct kvm_arch{ 
	struct sca_block *sca;

	debug_info_t *dbf;

	struct kvm_s390_float_interrupt float_int;

	struct kvm_device *flic;

	struct gmap *gmap;

	int css_support;

};

arch/s390/include/uapi/asm/kvm.h

+14 −0
Original line number Diff line number Diff line
@@ -16,6 +16,20 @@ 


#define __KVM_S390



/* Device control API: s390-specific devices */

#define KVM_DEV_FLIC_GET_ALL_IRQS	1

#define KVM_DEV_FLIC_ENQUEUE		2

#define KVM_DEV_FLIC_CLEAR_IRQS		3

/*

 * We can have up to 4*64k pending subchannels + 8 adapter interrupts,

 * as well as up  to ASYNC_PF_PER_VCPU*KVM_MAX_VCPUS pfault done interrupts.

 * There are also sclp and machine checks. This gives us

 * sizeof(kvm_s390_irq)*(4*65536+8+64*64+1+1) = 72 * 266250 = 19170000

 * Lets round up to 8192 pages.

 */



#define KVM_S390_FLIC_MAX_BUFFER	0x2000000



/* for KVM_GET_REGS and KVM_SET_REGS */

struct kvm_regs {

	/* general purpose regs for s390 */

arch/s390/kvm/interrupt.c

+253 −51
Original line number Diff line number Diff line
@@ -659,53 +659,86 @@ struct kvm_s390_interrupt_info *kvm_s390_get_io_int(struct kvm *kvm, 
	return inti;

}



int kvm_s390_inject_vm(struct kvm *kvm,

		       struct kvm_s390_interrupt *s390int)

static void __inject_vm(struct kvm *kvm, struct kvm_s390_interrupt_info *inti)

{

	struct kvm_s390_local_interrupt *li;

	struct kvm_s390_float_interrupt *fi;

	struct kvm_s390_interrupt_info *inti, *iter;

	struct kvm_s390_interrupt_info *iter;

	int sigcpu;



	mutex_lock(&kvm->lock);

	fi = &kvm->arch.float_int;

	spin_lock(&fi->lock);

	if (!is_ioint(inti->type)) {

		list_add_tail(&inti->list, &fi->list);

	} else {

		u64 isc_bits = int_word_to_isc_bits(inti->io.io_int_word);



		/* Keep I/O interrupts sorted in isc order. */

		list_for_each_entry(iter, &fi->list, list) {

			if (!is_ioint(iter->type))

				continue;

			if (int_word_to_isc_bits(iter->io.io_int_word)

			    <= isc_bits)

				continue;

			break;

		}

		list_add_tail(&inti->list, &iter->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);

}



int kvm_s390_inject_vm(struct kvm *kvm,

		       struct kvm_s390_interrupt *s390int)

{

	struct kvm_s390_interrupt_info *inti;



	inti = kzalloc(sizeof(*inti), GFP_KERNEL);

	if (!inti)

		return -ENOMEM;



	switch (s390int->type) {

	inti->type = s390int->type;

	switch (inti->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:

		kfree(inti);

		return -EINVAL;

	case KVM_S390_MCHK:

		VM_EVENT(kvm, 5, "inject: machine check parm64:%llx",

			 s390int->parm64);

		inti->type = s390int->type;

		inti->mchk.cr14 = s390int->parm; /* upper bits are not used */

		inti->mchk.mcic = s390int->parm64;

		break;

	case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX:

		if (s390int->type & IOINT_AI_MASK)

		if (inti->type & IOINT_AI_MASK)

			VM_EVENT(kvm, 5, "%s", "inject: I/O (AI)");

		else

			VM_EVENT(kvm, 5, "inject: I/O css %x ss %x schid %04x",

				 s390int->type & IOINT_CSSID_MASK,

				 s390int->type & IOINT_SSID_MASK,

				 s390int->type & IOINT_SCHID_MASK);

		inti->type = s390int->type;

		inti->io.subchannel_id = s390int->parm >> 16;

		inti->io.subchannel_nr = s390int->parm & 0x0000ffffu;

		inti->io.io_int_parm = s390int->parm64 >> 32;
@@ -718,42 +751,7 @@ int kvm_s390_inject_vm(struct kvm *kvm, 
	trace_kvm_s390_inject_vm(s390int->type, s390int->parm, s390int->parm64,

				 2);



	mutex_lock(&kvm->lock);

	fi = &kvm->arch.float_int;

	spin_lock(&fi->lock);

	if (!is_ioint(inti->type))

		list_add_tail(&inti->list, &fi->list);

	else {

		u64 isc_bits = int_word_to_isc_bits(inti->io.io_int_word);



		/* Keep I/O interrupts sorted in isc order. */

		list_for_each_entry(iter, &fi->list, list) {

			if (!is_ioint(iter->type))

				continue;

			if (int_word_to_isc_bits(iter->io.io_int_word)

			    <= isc_bits)

				continue;

			break;

		}

		list_add_tail(&inti->list, &iter->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);

	__inject_vm(kvm, inti);

	return 0;

}
@@ -841,3 +839,207 @@ int kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu, 
	mutex_unlock(&vcpu->kvm->lock);

	return 0;

}



static void clear_floating_interrupts(struct kvm *kvm)

{

	struct kvm_s390_float_interrupt *fi;

	struct kvm_s390_interrupt_info	*n, *inti = NULL;



	mutex_lock(&kvm->lock);

	fi = &kvm->arch.float_int;

	spin_lock(&fi->lock);

	list_for_each_entry_safe(inti, n, &fi->list, list) {

		list_del(&inti->list);

		kfree(inti);

	}

	atomic_set(&fi->active, 0);

	spin_unlock(&fi->lock);

	mutex_unlock(&kvm->lock);

}



static inline int copy_irq_to_user(struct kvm_s390_interrupt_info *inti,

				   u8 *addr)

{

	struct kvm_s390_irq __user *uptr = (struct kvm_s390_irq __user *) addr;

	struct kvm_s390_irq irq = {0};



	irq.type = inti->type;

	switch (inti->type) {

	case KVM_S390_INT_VIRTIO:

	case KVM_S390_INT_SERVICE:

		irq.u.ext = inti->ext;

		break;

	case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX:

		irq.u.io = inti->io;

		break;

	case KVM_S390_MCHK:

		irq.u.mchk = inti->mchk;

		break;

	default:

		return -EINVAL;

	}



	if (copy_to_user(uptr, &irq, sizeof(irq)))

		return -EFAULT;



	return 0;

}



static int get_all_floating_irqs(struct kvm *kvm, __u8 *buf, __u64 len)

{

	struct kvm_s390_interrupt_info *inti;

	struct kvm_s390_float_interrupt *fi;

	int ret = 0;

	int n = 0;



	mutex_lock(&kvm->lock);

	fi = &kvm->arch.float_int;

	spin_lock(&fi->lock);



	list_for_each_entry(inti, &fi->list, list) {

		if (len < sizeof(struct kvm_s390_irq)) {

			/* signal userspace to try again */

			ret = -ENOMEM;

			break;

		}

		ret = copy_irq_to_user(inti, buf);

		if (ret)

			break;

		buf += sizeof(struct kvm_s390_irq);

		len -= sizeof(struct kvm_s390_irq);

		n++;

	}



	spin_unlock(&fi->lock);

	mutex_unlock(&kvm->lock);



	return ret < 0 ? ret : n;

}



static int flic_get_attr(struct kvm_device *dev, struct kvm_device_attr *attr)

{

	int r;



	switch (attr->group) {

	case KVM_DEV_FLIC_GET_ALL_IRQS:

		r = get_all_floating_irqs(dev->kvm, (u8 *) attr->addr,

					  attr->attr);

		break;

	default:

		r = -EINVAL;

	}



	return r;

}



static inline int copy_irq_from_user(struct kvm_s390_interrupt_info *inti,

				     u64 addr)

{

	struct kvm_s390_irq __user *uptr = (struct kvm_s390_irq __user *) addr;

	void *target = NULL;

	void __user *source;

	u64 size;



	if (get_user(inti->type, (u64 __user *)addr))

		return -EFAULT;



	switch (inti->type) {

	case KVM_S390_INT_VIRTIO:

	case KVM_S390_INT_SERVICE:

		target = (void *) &inti->ext;

		source = &uptr->u.ext;

		size = sizeof(inti->ext);

		break;

	case KVM_S390_INT_IO_MIN...KVM_S390_INT_IO_MAX:

		target = (void *) &inti->io;

		source = &uptr->u.io;

		size = sizeof(inti->io);

		break;

	case KVM_S390_MCHK:

		target = (void *) &inti->mchk;

		source = &uptr->u.mchk;

		size = sizeof(inti->mchk);

		break;

	default:

		return -EINVAL;

	}



	if (copy_from_user(target, source, size))

		return -EFAULT;



	return 0;

}



static int enqueue_floating_irq(struct kvm_device *dev,

				struct kvm_device_attr *attr)

{

	struct kvm_s390_interrupt_info *inti = NULL;

	int r = 0;

	int len = attr->attr;



	if (len % sizeof(struct kvm_s390_irq) != 0)

		return -EINVAL;

	else if (len > KVM_S390_FLIC_MAX_BUFFER)

		return -EINVAL;



	while (len >= sizeof(struct kvm_s390_irq)) {

		inti = kzalloc(sizeof(*inti), GFP_KERNEL);

		if (!inti)

			return -ENOMEM;



		r = copy_irq_from_user(inti, attr->addr);

		if (r) {

			kfree(inti);

			return r;

		}

		__inject_vm(dev->kvm, inti);

		len -= sizeof(struct kvm_s390_irq);

		attr->addr += sizeof(struct kvm_s390_irq);

	}



	return r;

}



static int flic_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr)

{

	int r = 0;



	switch (attr->group) {

	case KVM_DEV_FLIC_ENQUEUE:

		r = enqueue_floating_irq(dev, attr);

		break;

	case KVM_DEV_FLIC_CLEAR_IRQS:

		r = 0;

		clear_floating_interrupts(dev->kvm);

		break;

	default:

		r = -EINVAL;

	}



	return r;

}



static int flic_create(struct kvm_device *dev, u32 type)

{

	if (!dev)

		return -EINVAL;

	if (dev->kvm->arch.flic)

		return -EINVAL;

	dev->kvm->arch.flic = dev;

	return 0;

}



static void flic_destroy(struct kvm_device *dev)

{

	dev->kvm->arch.flic = NULL;

	kfree(dev);

}



/* s390 floating irq controller (flic) */

struct kvm_device_ops kvm_flic_ops = {

	.name = "kvm-flic",

	.get_attr = flic_get_attr,

	.set_attr = flic_set_attr,

	.create = flic_create,

	.destroy = flic_destroy,

};

arch/s390/kvm/kvm-s390.c

+1 −0
Original line number Diff line number Diff line
@@ -157,6 +157,7 @@ int kvm_dev_ioctl_check_extension(long ext) 
	case KVM_CAP_ENABLE_CAP:

	case KVM_CAP_S390_CSS_SUPPORT:

	case KVM_CAP_IOEVENTFD:

	case KVM_CAP_DEVICE_CTRL:

		r = 1;

		break;

	case KVM_CAP_NR_VCPUS: