Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1163137 > unrolled thread

[v4 00/16] Add VT-d Posted-Interrupts support

Started byFeng Wu <feng.wu@intel.com>
First post2015-06-11 13:10 +0200
Last post2015-06-11 13:10 +0200
Articles 16 — 2 participants

Back to article view | Back to linux.kernel

Contents

  [v4 00/16] Add VT-d Posted-Interrupts support Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 12/16] KVM: kvm-vfio: implement the VFIO skeleton for VT-d Posted-Interrupts Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
      RE: [v4 12/16] KVM: kvm-vfio: implement the VFIO skeleton for VT-d  Posted-Interrupts "Wu, Feng" <feng.wu@intel.com> - 2015-06-12 07:00 +0200
    [v4 13/16] KVM: x86: kvm-vfio: VT-d posted-interrupts setup Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
      RE: [v4 13/16] KVM: x86: kvm-vfio: VT-d posted-interrupts setup "Wu, Feng" <feng.wu@intel.com> - 2015-06-12 07:00 +0200
    [v4 15/16] KVM: Update Posted-Interrupts Descriptor when vCPU is blocked Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 07/16] KVM: make kvm_set_msi_irq() public Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 10/16] KVM: kvm-vfio: wrappers to VFIO external API device helpers Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 11/16] KVM: kvm-vfio: User API for VT-d Posted-Interrupts Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 05/16] KVM: Add interfaces to control PI outside vmx Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 14/16] KVM: Update Posted-Interrupts Descriptor when vCPU is preempted Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 02/16] KVM: Add some helper functions for Posted-Interrupts Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 16/16] KVM: Warn if 'SN' is set during posting interrupts by software Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 04/16] KVM: Get Posted-Interrupts descriptor address from struct kvm_vcpu Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 01/16] KVM: Extend struct pi_desc for VT-d Posted-Interrupts Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200
    [v4 09/16] VFIO: external user API for interaction Feng Wu <feng.wu@intel.com> - 2015-06-11 13:10 +0200

#1163137 — [v4 00/16] Add VT-d Posted-Interrupts support

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 00/16] Add VT-d Posted-Interrupts support
Message-ID<pA8wV-3OV-5@gated-at.bofh.it>
VT-d Posted-Interrupts is an enhancement to CPU side Posted-Interrupt.
With VT-d Posted-Interrupts enabled, external interrupts from
direct-assigned devices can be delivered to guests without VMM
intervention when guest is running in non-root mode.

You can find the VT-d Posted-Interrtups Spec. in the following URL:
http://www.intel.com/content/www/us/en/intelligent-systems/intel-technology/vt-directed-io-spec.html

This series was part of http://thread.gmane.org/gmane.linux.kernel.iommu/7708. To make things clear, send out IOMMU part here.

This patch-set is based on the lastest x86/apic branch of tip tree.

Divide the whole series which contain multiple components into three parts:
- Prerequisite changes to irq subsystem (already merged in tip/x86/apic)
- IOMMU part (about to be merged in merged in tip/x86/apic), here is the
  latest version: https://lkml.org/lkml/2015/6/9/22
- KVM and VFIO parts (this series)

Patch 8, 9, and 10 are from Eric Auger, there are some common VFIO APIs
defined in them. I integrate them in this series and use the APIs in
my patches.

v4:
* For lowest-priority interrupt, only support single-CPU destination
interrupts at the current stage, more common lowest priority support
will be added later.
* Accoring to Marcelo's suggestion, when vCPU is blocked, we handle
the posted-interrupts in the HLT emulation path.
* Some small changes (coding style, typo, add some code comments)

Eric Auger (3):
  KVM: kvm-vfio: User API for IRQ forwarding
  VFIO: external user API for interaction
  KVM: kvm-vfio: wrappers to VFIO external API device helpers

Feng Wu (13):
  KVM: Extend struct pi_desc for VT-d Posted-Interrupts
  KVM: Add some helper functions for Posted-Interrupts
  KVM: Define a new interface kvm_intr_is_single_vcpu()
  KVM: Get Posted-Interrupts descriptor address from struct kvm_vcpu
  KVM: Add interfaces to control PI outside vmx
  KVM: Make struct kvm_irq_routing_table accessible
  KVM: make kvm_set_msi_irq() public
  KVM: kvm-vfio: User API for VT-d Posted-Interrupts
  KVM: kvm-vfio: implement the VFIO skeleton for VT-d Posted-Interrupts
  KVM: x86: kvm-vfio: VT-d posted-interrupts setup
  KVM: Update Posted-Interrupts Descriptor when vCPU is preempted
  KVM: Update Posted-Interrupts Descriptor when vCPU is blocked
  KVM: Warn if 'SN' is set during posting interrupts by software

 Documentation/virtual/kvm/devices/vfio.txt |  43 ++++-
 arch/x86/include/asm/kvm_host.h            |  16 ++
 arch/x86/kvm/Makefile                      |   3 +-
 arch/x86/kvm/irq_comm.c                    |  28 ++-
 arch/x86/kvm/kvm_vfio_x86.c                |  85 +++++++++
 arch/x86/kvm/vmx.c                         | 278 ++++++++++++++++++++++++++++-
 arch/x86/kvm/x86.c                         |  42 +++--
 drivers/vfio/vfio.c                        |  24 +++
 include/linux/kvm_host.h                   |  40 +++++
 include/linux/vfio.h                       |   3 +
 include/uapi/linux/kvm.h                   |  14 ++
 virt/kvm/irqchip.c                         |  11 --
 virt/kvm/kvm_main.c                        |   3 +
 virt/kvm/vfio.c                            | 200 +++++++++++++++++++++
 14 files changed, 758 insertions(+), 32 deletions(-)
 create mode 100644 arch/x86/kvm/kvm_vfio_x86.c

-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1163138 — [v4 12/16] KVM: kvm-vfio: implement the VFIO skeleton for VT-d Posted-Interrupts

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 12/16] KVM: kvm-vfio: implement the VFIO skeleton for VT-d Posted-Interrupts
Message-ID<pA8wV-3OV-19@gated-at.bofh.it>
In reply to#1163137
This patch adds the kvm-vfio interface for VT-d Posted-Interrupts.
When guests update MSI/MSI-x information for an assigned-device,
QEMU will use KVM_DEV_VFIO_DEVICE_POST_IRQ attribute to setup
IRTE for VT-d PI. Userspace program can also use
KVM_DEV_VFIO_DEVICE_UNPOST_IRQ to change back to irq remapping mode.
This patch implements these IRQ attributes.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 include/linux/kvm_host.h |  22 +++++++++
 virt/kvm/vfio.c          | 126 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 148 insertions(+)

diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index f591f7c..69f8711 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -1073,6 +1073,28 @@ extern struct kvm_device_ops kvm_xics_ops;
 extern struct kvm_device_ops kvm_arm_vgic_v2_ops;
 extern struct kvm_device_ops kvm_arm_vgic_v3_ops;
 
+#ifdef __KVM_HAVE_ARCH_KVM_VFIO_POST
+/*
+ * kvm_arch_vfio_update_pi_irte - set IRTE for Posted-Interrupts
+ *
+ * @kvm: kvm
+ * @host_irq: host irq of the interrupt
+ * @guest_irq: gsi of the interrupt
+ * @set: set or unset PI
+ * returns 0 on success, < 0 on failure
+ */
+int kvm_arch_vfio_update_pi_irte(struct kvm *kvm, unsigned int host_irq,
+				 uint32_t guest_irq, bool set);
+#else
+static inline int kvm_arch_vfio_update_pi_irte(struct kvm *kvm,
+					       unsigned int host_irq,
+					       uint32_t guest_irq,
+					       bool set)
+{
+	return 0;
+}
+#endif
+
 #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
 
 static inline void kvm_vcpu_set_in_spin_loop(struct kvm_vcpu *vcpu, bool val)
diff --git a/virt/kvm/vfio.c b/virt/kvm/vfio.c
index 80a45e4..547fc51 100644
--- a/virt/kvm/vfio.c
+++ b/virt/kvm/vfio.c
@@ -18,6 +18,7 @@
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/vfio.h>
+#include <asm/irq_remapping.h>
 #include "vfio.h"
 
 struct kvm_vfio_group {
@@ -276,12 +277,128 @@ static int kvm_vfio_set_group(struct kvm_device *dev, long attr, u64 arg)
 	return -ENXIO;
 }
 
+static int kvm_vfio_pci_get_irq_count(struct pci_dev *pdev, int irq_type)
+{
+	if (irq_type == VFIO_PCI_INTX_IRQ_INDEX) {
+		u8 pin;
+
+		pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
+		if (pin)
+			return 1;
+	} else if (irq_type == VFIO_PCI_MSI_IRQ_INDEX) {
+		return pci_msi_vec_count(pdev);
+	} else if (irq_type == VFIO_PCI_MSIX_IRQ_INDEX) {
+		return pci_msix_vec_count(pdev);
+	}
+
+	return 0;
+}
+
+static int kvm_vfio_control_pi(struct kvm_device *kdev,
+			       int32_t __user *argp, bool set)
+{
+	struct kvm_vfio_dev_irq pi_info;
+	uint32_t *gsi;
+	unsigned long minsz;
+	struct vfio_device *vdev;
+	struct msi_desc *entry;
+	struct device *dev;
+	struct pci_dev *pdev;
+	int i, max, ret;
+
+	minsz = offsetofend(struct kvm_vfio_dev_irq, count);
+
+	if (copy_from_user(&pi_info, (void __user *)argp, minsz))
+		return -EFAULT;
+
+	if (pi_info.argsz < minsz || pi_info.index >= VFIO_PCI_NUM_IRQS)
+		return -EINVAL;
+
+	vdev = kvm_vfio_get_vfio_device(pi_info.fd);
+	if (IS_ERR(vdev))
+		return PTR_ERR(vdev);
+
+	dev = kvm_vfio_external_base_device(vdev);
+	if (!dev || !dev_is_pci(dev)) {
+		ret = -EFAULT;
+		goto put_vfio_device;
+	}
+
+	pdev = to_pci_dev(dev);
+
+	max = kvm_vfio_pci_get_irq_count(pdev, pi_info.index);
+	if (max <= 0) {
+		ret = -EFAULT;
+		goto put_vfio_device;
+	}
+
+	if (pi_info.argsz - minsz < pi_info.count * sizeof(u32) ||
+	    pi_info.start >= max || pi_info.start + pi_info.count > max) {
+		ret = -EINVAL;
+		goto put_vfio_device;
+	}
+
+	gsi = memdup_user((void __user *)((unsigned long)argp + minsz),
+			   pi_info.count * sizeof(u32));
+	if (IS_ERR(gsi)) {
+		ret = PTR_ERR(gsi);
+		goto put_vfio_device;
+	}
+
+#ifdef CONFIG_PCI_MSI
+	for (i = 0; i < pi_info.count; i++) {
+		list_for_each_entry(entry, &pdev->msi_list, list) {
+			if (entry->msi_attrib.entry_nr != pi_info.start+i)
+				continue;
+
+			ret = kvm_arch_vfio_update_pi_irte(kdev->kvm,
+							   entry->irq,
+							   gsi[i],
+							   set);
+			if (ret)
+				goto free_gsi;
+		}
+	}
+#endif
+
+	ret = 0;
+
+free_gsi:
+	kfree(gsi);
+
+put_vfio_device:
+	kvm_vfio_put_vfio_device(vdev);
+	return ret;
+}
+
+static int kvm_vfio_set_device(struct kvm_device *kdev, long attr, u64 arg)
+{
+	int32_t __user *argp = (int32_t __user *)(unsigned long)arg;
+	int ret;
+
+	switch (attr) {
+#ifdef __KVM_HAVE_ARCH_KVM_VFIO_POST
+	case KVM_DEV_VFIO_DEVICE_POST_IRQ:
+		ret = kvm_vfio_control_pi(kdev, argp, 1);
+		break;
+	case KVM_DEV_VFIO_DEVICE_UNPOST_IRQ:
+		ret = kvm_vfio_control_pi(kdev, argp, 0);
+		break;
+#endif
+	default:
+		ret = -ENXIO;
+	}
+	return ret;
+}
+
 static int kvm_vfio_set_attr(struct kvm_device *dev,
 			     struct kvm_device_attr *attr)
 {
 	switch (attr->group) {
 	case KVM_DEV_VFIO_GROUP:
 		return kvm_vfio_set_group(dev, attr->attr, attr->addr);
+	case KVM_DEV_VFIO_DEVICE:
+		return kvm_vfio_set_device(dev, attr->attr, attr->addr);
 	}
 
 	return -ENXIO;
@@ -299,6 +416,15 @@ static int kvm_vfio_has_attr(struct kvm_device *dev,
 		}
 
 		break;
+	case KVM_DEV_VFIO_DEVICE:
+		switch (attr->attr) {
+#ifdef __KVM_HAVE_ARCH_KVM_VFIO_POST
+		case KVM_DEV_VFIO_DEVICE_POST_IRQ:
+		case KVM_DEV_VFIO_DEVICE_UNPOST_IRQ:
+			return irq_remapping_cap(IRQ_POSTING_CAP) ? 0 : -ENXIO;
+#endif
+		}
+		break;
 	}
 
 	return -ENXIO;
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163758 — RE: [v4 12/16] KVM: kvm-vfio: implement the VFIO skeleton for VT-d Posted-Interrupts

From"Wu, Feng" <feng.wu@intel.com>
Date2015-06-12 07:00 +0200
SubjectRE: [v4 12/16] KVM: kvm-vfio: implement the VFIO skeleton for VT-d Posted-Interrupts
Message-ID<pApep-3pn-3@gated-at.bofh.it>
In reply to#1163138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=
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163139 — [v4 13/16] KVM: x86: kvm-vfio: VT-d posted-interrupts setup

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 13/16] KVM: x86: kvm-vfio: VT-d posted-interrupts setup
Message-ID<pA8wV-3OV-21@gated-at.bofh.it>
In reply to#1163137
This patch defines macro __KVM_HAVE_ARCH_KVM_VFIO_POST and
implement kvm_arch_vfio_update_pi_irte for x86 architecture.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/include/asm/kvm_host.h |  2 +
 arch/x86/kvm/Makefile           |  3 +-
 arch/x86/kvm/kvm_vfio_x86.c     | 85 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 89 insertions(+), 1 deletion(-)
 create mode 100644 arch/x86/kvm/kvm_vfio_x86.c

diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h
index 31a495f..1605bf8 100644
--- a/arch/x86/include/asm/kvm_host.h
+++ b/arch/x86/include/asm/kvm_host.h
@@ -81,6 +81,8 @@ static inline gfn_t gfn_to_index(gfn_t gfn, gfn_t base_gfn, int level)
 		(base_gfn >> KVM_HPAGE_GFN_SHIFT(level));
 }
 
+#define __KVM_HAVE_ARCH_KVM_VFIO_POST
+
 #define KVM_PERMILLE_MMU_PAGES 20
 #define KVM_MIN_ALLOC_MMU_PAGES 64
 #define KVM_MMU_HASH_SHIFT 10
diff --git a/arch/x86/kvm/Makefile b/arch/x86/kvm/Makefile
index 16e8f96..6bafc89 100644
--- a/arch/x86/kvm/Makefile
+++ b/arch/x86/kvm/Makefile
@@ -12,7 +12,8 @@ kvm-y			+= $(KVM)/kvm_main.o $(KVM)/coalesced_mmio.o \
 kvm-$(CONFIG_KVM_ASYNC_PF)	+= $(KVM)/async_pf.o
 
 kvm-y			+= x86.o mmu.o emulate.o i8259.o irq.o lapic.o \
-			   i8254.o ioapic.o irq_comm.o cpuid.o pmu.o
+			   i8254.o ioapic.o irq_comm.o cpuid.o pmu.o \
+			   kvm_vfio_x86.o
 kvm-$(CONFIG_KVM_DEVICE_ASSIGNMENT)	+= assigned-dev.o iommu.o
 kvm-intel-y		+= vmx.o
 kvm-amd-y		+= svm.o
diff --git a/arch/x86/kvm/kvm_vfio_x86.c b/arch/x86/kvm/kvm_vfio_x86.c
new file mode 100644
index 0000000..a2d74f9
--- /dev/null
+++ b/arch/x86/kvm/kvm_vfio_x86.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2014 Intel Corporation.
+ * Authors: Feng Wu <feng.wu@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kvm_host.h>
+#include <asm/irq_remapping.h>
+
+/*
+ * kvm_arch_vfio_update_pi_irte - set IRTE for Posted-Interrupts
+ *
+ * @kvm: kvm
+ * @host_irq: host irq of the interrupt
+ * @guest_irq: gsi of the interrupt
+ * @set: set or unset PI
+ * returns 0 on success, < 0 on failure
+ */
+int kvm_arch_vfio_update_pi_irte(struct kvm *kvm, unsigned int host_irq,
+				 uint32_t guest_irq, bool set)
+{
+	struct kvm_kernel_irq_routing_entry *e;
+	struct kvm_irq_routing_table *irq_rt;
+	struct kvm_lapic_irq irq;
+	struct kvm_vcpu *vcpu;
+	struct vcpu_data vcpu_info;
+	int idx, ret = -EINVAL;
+
+	idx = srcu_read_lock(&kvm->irq_srcu);
+	irq_rt = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu);
+	BUG_ON(guest_irq >= irq_rt->nr_rt_entries);
+
+	hlist_for_each_entry(e, &irq_rt->map[guest_irq], link) {
+		if (e->type != KVM_IRQ_ROUTING_MSI)
+			continue;
+		/*
+		 * VT-d PI cannot support posting multicast/broadcast
+		 * interrupts to a VCPU, we still use interrupt remapping
+		 * for these kind of interrupts.
+		 *
+		 * For lowest-priority interrupts, we only support
+		 * those with single CPU as the destination, e.g. user
+		 * configures the interrupts via /proc/irq or uses
+		 * irqbalance to make the interrupts single-CPU.
+		 *
+		 * We will support full lowest-priority interrupt later.
+		 *
+		 */
+
+		kvm_set_msi_irq(e, &irq);
+		if (!kvm_intr_is_single_vcpu(kvm, &irq, &vcpu))
+			continue;
+
+		vcpu_info.pi_desc_addr = kvm_x86_ops->get_pi_desc_addr(vcpu);
+		vcpu_info.vector = irq.vector;
+
+		if (set)
+			ret = irq_set_vcpu_affinity(host_irq, &vcpu_info);
+		else {
+			/* suppress notification event before unposting */
+			kvm_x86_ops->pi_set_sn(vcpu);
+			ret = irq_set_vcpu_affinity(host_irq, NULL);
+			kvm_x86_ops->pi_clear_sn(vcpu);
+		}
+
+		if (ret < 0) {
+			printk(KERN_INFO "%s: failed to update PI IRTE\n",
+					__func__);
+			goto out;
+		}
+	}
+
+	ret = 0;
+out:
+	srcu_read_unlock(&kvm->irq_srcu, idx);
+	return ret;
+}
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163757 — RE: [v4 13/16] KVM: x86: kvm-vfio: VT-d posted-interrupts setup

From"Wu, Feng" <feng.wu@intel.com>
Date2015-06-12 07:00 +0200
SubjectRE: [v4 13/16] KVM: x86: kvm-vfio: VT-d posted-interrupts setup
Message-ID<pApep-3pn-1@gated-at.bofh.it>
In reply to#1163139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==
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163140 — [v4 15/16] KVM: Update Posted-Interrupts Descriptor when vCPU is blocked

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 15/16] KVM: Update Posted-Interrupts Descriptor when vCPU is blocked
Message-ID<pA8wW-3OV-23@gated-at.bofh.it>
In reply to#1163137
This patch updates the Posted-Interrupts Descriptor when vCPU
is blocked.

pre-block:
- Add the vCPU to the blocked per-CPU list
- Set 'NV' to POSTED_INTR_WAKEUP_VECTOR

post-block:
- Remove the vCPU from the per-CPU list

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/include/asm/kvm_host.h |   3 +
 arch/x86/kvm/vmx.c              | 158 ++++++++++++++++++++++++++++++++++++++++
 arch/x86/kvm/x86.c              |  42 ++++++++---
 include/linux/kvm_host.h        |   3 +
 virt/kvm/kvm_main.c             |   3 +
 5 files changed, 199 insertions(+), 10 deletions(-)

diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h
index 1605bf8..2ef6f2a 100644
--- a/arch/x86/include/asm/kvm_host.h
+++ b/arch/x86/include/asm/kvm_host.h
@@ -842,6 +842,9 @@ struct kvm_x86_ops {
 
 	void (*pi_clear_sn)(struct kvm_vcpu *vcpu);
 	void (*pi_set_sn)(struct kvm_vcpu *vcpu);
+
+	int (*pi_pre_block)(struct kvm_vcpu *vcpu);
+	void (*pi_post_block)(struct kvm_vcpu *vcpu);
 };
 
 struct kvm_arch_async_pf {
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index 9d9b403..7e8a800 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -888,6 +888,13 @@ static DEFINE_PER_CPU(struct vmcs *, current_vmcs);
 static DEFINE_PER_CPU(struct list_head, loaded_vmcss_on_cpu);
 static DEFINE_PER_CPU(struct desc_ptr, host_gdt);
 
+/*
+ * We maintian a per-CPU linked-list of vCPU, so in wakeup_handler() we
+ * can find which vCPU should be waken up.
+ */
+static DEFINE_PER_CPU(struct list_head, blocked_vcpu_on_cpu);
+static DEFINE_PER_CPU(spinlock_t, blocked_vcpu_on_cpu_lock);
+
 static unsigned long *vmx_io_bitmap_a;
 static unsigned long *vmx_io_bitmap_b;
 static unsigned long *vmx_msr_bitmap_legacy;
@@ -2972,6 +2979,8 @@ static int hardware_enable(void)
 		return -EBUSY;
 
 	INIT_LIST_HEAD(&per_cpu(loaded_vmcss_on_cpu, cpu));
+	INIT_LIST_HEAD(&per_cpu(blocked_vcpu_on_cpu, cpu));
+	spin_lock_init(&per_cpu(blocked_vcpu_on_cpu_lock, cpu));
 
 	/*
 	 * Now we can enable the vmclear operation in kdump
@@ -6099,6 +6108,25 @@ static void update_ple_window_actual_max(void)
 			                    ple_window_grow, INT_MIN);
 }
 
+/*
+ * Handler for POSTED_INTERRUPT_WAKEUP_VECTOR.
+ */
+static void wakeup_handler(void)
+{
+	struct kvm_vcpu *vcpu;
+	int cpu = smp_processor_id();
+
+	spin_lock(&per_cpu(blocked_vcpu_on_cpu_lock, cpu));
+	list_for_each_entry(vcpu, &per_cpu(blocked_vcpu_on_cpu, cpu),
+			blocked_vcpu_list) {
+		struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
+
+		if (pi_test_on(pi_desc) == 1)
+			kvm_vcpu_kick(vcpu);
+	}
+	spin_unlock(&per_cpu(blocked_vcpu_on_cpu_lock, cpu));
+}
+
 static __init int hardware_setup(void)
 {
 	int r = -ENOMEM, i, msr;
@@ -6283,6 +6311,8 @@ static __init int hardware_setup(void)
 		kvm_x86_ops->enable_log_dirty_pt_masked = NULL;
 	}
 
+	kvm_set_posted_intr_wakeup_handler(wakeup_handler);
+
 	return alloc_kvm_area();
 
 out8:
@@ -10236,6 +10266,131 @@ static void vmx_enable_log_dirty_pt_masked(struct kvm *kvm,
 	kvm_mmu_clear_dirty_pt_masked(kvm, memslot, offset, mask);
 }
 
+/*
+ * This routine does the following things for vCPU which is going
+ * to be blocked if VT-d PI is enabled.
+ * - Store the vCPU to the wakeup list, so when interrupts happen
+ *   we can find the right vCPU to wake up.
+ * - Change the Posted-interrupt descriptor as below:
+ *      'NDST' <-- vcpu->pre_pcpu
+ *      'NV' <-- POSTED_INTR_WAKEUP_VECTOR
+ * - If 'ON' is set during this process, which means at least one
+ *   interrupt is posted for this vCPU, we cannot block it, in
+ *   this case, return 1, otherwise, return 0.
+ *
+ */
+static int vmx_pi_pre_block(struct kvm_vcpu *vcpu)
+{
+	unsigned long flags;
+	unsigned int dest;
+	struct pi_desc old, new;
+	struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
+
+	if (!irq_remapping_cap(IRQ_POSTING_CAP))
+		return 0;
+
+	vcpu->pre_pcpu = vcpu->cpu;
+	spin_lock_irqsave(&per_cpu(blocked_vcpu_on_cpu_lock,
+			  vcpu->pre_pcpu), flags);
+	list_add_tail(&vcpu->blocked_vcpu_list,
+		      &per_cpu(blocked_vcpu_on_cpu,
+		      vcpu->pre_pcpu));
+	spin_unlock_irqrestore(&per_cpu(blocked_vcpu_on_cpu_lock,
+			       vcpu->pre_pcpu), flags);
+
+	do {
+		old.control = new.control = pi_desc->control;
+
+		/*
+		 * We should not block the vCPU if
+		 * an interrupt is posted for it.
+		 */
+		if (pi_test_on(pi_desc) == 1) {
+			spin_lock_irqsave(&per_cpu(blocked_vcpu_on_cpu_lock,
+					  vcpu->pre_pcpu), flags);
+			list_del(&vcpu->blocked_vcpu_list);
+			spin_unlock_irqrestore(
+					&per_cpu(blocked_vcpu_on_cpu_lock,
+					vcpu->pre_pcpu), flags);
+			vcpu->pre_pcpu = -1;
+
+			return 1;
+		}
+
+		WARN((pi_desc->sn == 1),
+		     "Warning: SN field of posted-interrupts "
+		     "is set before blocking\n");
+
+		/*
+		 * Since vCPU can be preempted during this process,
+		 * vcpu->cpu could be different with pre_pcpu, we
+		 * need to set pre_pcpu as the destination of wakeup
+		 * notification event, then we can find the right vCPU
+		 * to wakeup in wakeup handler if interrupts happen
+		 * when the vCPU is in blocked state.
+		 */
+		dest = cpu_physical_id(vcpu->pre_pcpu);
+
+		if (x2apic_enabled())
+			new.ndst = dest;
+		else
+			new.ndst = (dest << 8) & 0xFF00;
+
+		/* set 'NV' to 'wakeup vector' */
+		new.nv = POSTED_INTR_WAKEUP_VECTOR;
+	} while (cmpxchg(&pi_desc->control, old.control,
+			new.control) != old.control);
+
+	return 0;
+}
+
+static void vmx_pi_post_block(struct kvm_vcpu *vcpu)
+{
+	struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
+	struct pi_desc old, new;
+	unsigned int dest;
+	unsigned long flags;
+
+	if (!irq_remapping_cap(IRQ_POSTING_CAP))
+		return;
+
+	/*
+	 * If the vCPU is not really blocked and vmx_vcpu_load()
+	 * doesn't have chance to run before this point, we should
+	 * set posted-interrupt descriptor back, just like what we
+	 * do in vmx_vcpu_load().
+	 */
+	if (pi_desc->nv == POSTED_INTR_WAKEUP_VECTOR)
+		do {
+			old.control = new.control = pi_desc->control;
+
+			dest = cpu_physical_id(vcpu->cpu);
+
+			if (x2apic_enabled())
+				new.ndst = dest;
+			else
+				new.ndst = (dest << 8) & 0xFF00;
+
+			/* Allow posting non-urgent interrupts */
+			new.sn = 0;
+
+			/* set 'NV' to 'notification vector' */
+			new.nv = POSTED_INTR_VECTOR;
+		} while (cmpxchg(&pi_desc->control, old.control,
+				new.control) != old.control);
+
+	if(vcpu->pre_pcpu != -1) {
+		spin_lock_irqsave(
+			&per_cpu(blocked_vcpu_on_cpu_lock,
+			vcpu->pre_pcpu), flags);
+		list_del(&vcpu->blocked_vcpu_list);
+		spin_unlock_irqrestore(
+			&per_cpu(blocked_vcpu_on_cpu_lock,
+			vcpu->pre_pcpu), flags);
+		vcpu->pre_pcpu = -1;
+	}
+}
+
 static struct kvm_x86_ops vmx_x86_ops = {
 	.cpu_has_kvm_support = cpu_has_kvm_support,
 	.disabled_by_bios = vmx_disabled_by_bios,
@@ -10354,6 +10509,9 @@ static struct kvm_x86_ops vmx_x86_ops = {
 
 	.pi_clear_sn = vmx_pi_clear_sn,
 	.pi_set_sn = vmx_pi_set_sn,
+
+	.pi_pre_block = vmx_pi_pre_block,
+	.pi_post_block = vmx_pi_post_block,
 };
 
 static int __init vmx_init(void)
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index c73efcd..fabf4a7 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -5866,7 +5866,11 @@ int kvm_vcpu_halt(struct kvm_vcpu *vcpu)
 {
 	++vcpu->stat.halt_exits;
 	if (irqchip_in_kernel(vcpu->kvm)) {
-		vcpu->arch.mp_state = KVM_MP_STATE_HALTED;
+		/* Handle posted-interrupt when vCPU is to be halted */
+		if (!kvm_x86_ops->pi_pre_block ||
+		    (kvm_x86_ops->pi_pre_block &&
+		    kvm_x86_ops->pi_pre_block(vcpu) == 0))
+			vcpu->arch.mp_state = KVM_MP_STATE_HALTED;
 		return 1;
 	} else {
 		vcpu->run->exit_reason = KVM_EXIT_HLT;
@@ -6282,6 +6286,21 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
 			kvm_vcpu_reload_apic_access_page(vcpu);
 	}
 
+	/*
+	 * Since posted-interrupts can be set by VT-d HW now, in this
+	 * case, KVM_REQ_EVENT is not set. We move the following
+	 * operations out of the if statement.
+	 */
+	if (kvm_lapic_enabled(vcpu)) {
+		/*
+		 * Update architecture specific hints for APIC
+		 * virtual interrupt delivery.
+		 */
+		if (kvm_x86_ops->hwapic_irr_update)
+			kvm_x86_ops->hwapic_irr_update(vcpu,
+				kvm_lapic_find_highest_irr(vcpu));
+	}
+
 	if (kvm_check_request(KVM_REQ_EVENT, vcpu) || req_int_win) {
 		kvm_apic_accept_events(vcpu);
 		if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {
@@ -6298,13 +6317,6 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
 			kvm_x86_ops->enable_irq_window(vcpu);
 
 		if (kvm_lapic_enabled(vcpu)) {
-			/*
-			 * Update architecture specific hints for APIC
-			 * virtual interrupt delivery.
-			 */
-			if (kvm_x86_ops->hwapic_irr_update)
-				kvm_x86_ops->hwapic_irr_update(vcpu,
-					kvm_lapic_find_highest_irr(vcpu));
 			update_cr8_intercept(vcpu);
 			kvm_lapic_sync_to_vapic(vcpu);
 		}
@@ -6475,10 +6487,20 @@ static int vcpu_run(struct kvm_vcpu *vcpu)
 
 	for (;;) {
 		if (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE &&
-		    !vcpu->arch.apf.halted)
+		    !vcpu->arch.apf.halted) {
 			r = vcpu_enter_guest(vcpu);
-		else
+		} else {
 			r = vcpu_block(kvm, vcpu);
+
+			/*
+			 * pi_post_block() must be called after
+			 * pi_pre_block() which is called in
+			 * kvm_vcpu_halt().
+			 */
+			if (kvm_x86_ops->pi_post_block)
+				kvm_x86_ops->pi_post_block(vcpu);
+		}
+
 		if (r <= 0)
 			break;
 
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 69f8711..6c90ef2 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -225,6 +225,9 @@ struct kvm_vcpu {
 	unsigned long requests;
 	unsigned long guest_debug;
 
+	int pre_pcpu;
+	struct list_head blocked_vcpu_list;
+
 	struct mutex mutex;
 	struct kvm_run *run;
 
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index 9097741..6938554 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -221,6 +221,9 @@ int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id)
 	init_waitqueue_head(&vcpu->wq);
 	kvm_async_pf_vcpu_init(vcpu);
 
+	vcpu->pre_pcpu = -1;
+	INIT_LIST_HEAD(&vcpu->blocked_vcpu_list);
+
 	page = alloc_page(GFP_KERNEL | __GFP_ZERO);
 	if (!page) {
 		r = -ENOMEM;
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163142 — [v4 07/16] KVM: make kvm_set_msi_irq() public

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 07/16] KVM: make kvm_set_msi_irq() public
Message-ID<pA8wW-3OV-29@gated-at.bofh.it>
In reply to#1163137
Make kvm_set_msi_irq() public, we can use this function outside.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/include/asm/kvm_host.h | 4 ++++
 arch/x86/kvm/irq_comm.c         | 4 ++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h
index 69bc770..31a495f 100644
--- a/arch/x86/include/asm/kvm_host.h
+++ b/arch/x86/include/asm/kvm_host.h
@@ -175,6 +175,8 @@ enum {
  */
 #define KVM_APIC_PV_EOI_PENDING	1
 
+struct kvm_kernel_irq_routing_entry;
+
 /*
  * We don't want allocation failures within the mmu code, so we preallocate
  * enough memory for a single page fault in a cache.
@@ -1186,4 +1188,6 @@ void kvm_deliver_pmi(struct kvm_vcpu *vcpu);
 
 bool kvm_intr_is_single_vcpu(struct kvm *kvm, struct kvm_lapic_irq *irq,
 			     struct kvm_vcpu **dest_vcpu);
+void kvm_set_msi_irq(struct kvm_kernel_irq_routing_entry *e,
+		     struct kvm_lapic_irq *irq);
 #endif /* _ASM_X86_KVM_HOST_H */
diff --git a/arch/x86/kvm/irq_comm.c b/arch/x86/kvm/irq_comm.c
index 9e42645..58d7d49 100644
--- a/arch/x86/kvm/irq_comm.c
+++ b/arch/x86/kvm/irq_comm.c
@@ -94,8 +94,8 @@ int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
 	return r;
 }
 
-static inline void kvm_set_msi_irq(struct kvm_kernel_irq_routing_entry *e,
-				   struct kvm_lapic_irq *irq)
+void kvm_set_msi_irq(struct kvm_kernel_irq_routing_entry *e,
+		     struct kvm_lapic_irq *irq)
 {
 	trace_kvm_msi_set_irq(e->msi.address_lo, e->msi.data);
 
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163143 — [v4 10/16] KVM: kvm-vfio: wrappers to VFIO external API device helpers

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 10/16] KVM: kvm-vfio: wrappers to VFIO external API device helpers
Message-ID<pA8wW-3OV-31@gated-at.bofh.it>
In reply to#1163137
From: Eric Auger <eric.auger@linaro.org>

Provide wrapper functions that allow KVM-VFIO device code to
interact with a vfio device:
- kvm_vfio_device_get_external_user gets a handle to a struct
  vfio_device from the vfio device file descriptor and increments
  its reference counter,
- kvm_vfio_device_put_external_user decrements the reference counter
  to a vfio device,
- kvm_vfio_external_base_device returns a handle to the struct device
  of the vfio device.

Also kvm_vfio_get_vfio_device and kvm_vfio_put_vfio_device helpers
are introduced.

Signed-off-by: Eric Auger <eric.auger@linaro.org>
---
 virt/kvm/vfio.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/virt/kvm/vfio.c b/virt/kvm/vfio.c
index 620e37f..80a45e4 100644
--- a/virt/kvm/vfio.c
+++ b/virt/kvm/vfio.c
@@ -60,6 +60,80 @@ static void kvm_vfio_group_put_external_user(struct vfio_group *vfio_group)
 	symbol_put(vfio_group_put_external_user);
 }
 
+static struct vfio_device *kvm_vfio_device_get_external_user(struct file *filep)
+{
+	struct vfio_device *vdev;
+	struct vfio_device *(*fn)(struct file *);
+
+	fn = symbol_get(vfio_device_get_external_user);
+	if (!fn)
+		return ERR_PTR(-EINVAL);
+
+	vdev = fn(filep);
+
+	symbol_put(vfio_device_get_external_user);
+
+	return vdev;
+}
+
+static void kvm_vfio_device_put_external_user(struct vfio_device *vdev)
+{
+	void (*fn)(struct vfio_device *);
+
+	fn = symbol_get(vfio_device_put_external_user);
+	if (!fn)
+		return;
+
+	fn(vdev);
+
+	symbol_put(vfio_device_put_external_user);
+}
+
+static struct device *kvm_vfio_external_base_device(struct vfio_device *vdev)
+{
+	struct device *(*fn)(struct vfio_device *);
+	struct device *dev;
+
+	fn = symbol_get(vfio_external_base_device);
+	if (!fn)
+		return NULL;
+
+	dev = fn(vdev);
+
+	symbol_put(vfio_external_base_device);
+
+	return dev;
+}
+
+/**
+ * kvm_vfio_get_vfio_device - Returns a handle to a vfio-device
+ *
+ * Checks it is a valid vfio device and increments its reference counter
+ * @fd: file descriptor of the vfio platform device
+ */
+static struct vfio_device *kvm_vfio_get_vfio_device(int fd)
+{
+	struct fd f = fdget(fd);
+	struct vfio_device *vdev;
+
+	if (!f.file)
+		return ERR_PTR(-EINVAL);
+	vdev = kvm_vfio_device_get_external_user(f.file);
+	fdput(f);
+	return vdev;
+}
+
+/**
+ * kvm_vfio_put_vfio_device: decrements the reference counter of the
+ * vfio platform * device
+ *
+ * @vdev: vfio_device handle to release
+ */
+static void kvm_vfio_put_vfio_device(struct vfio_device *vdev)
+{
+	kvm_vfio_device_put_external_user(vdev);
+}
+
 static bool kvm_vfio_group_is_coherent(struct vfio_group *vfio_group)
 {
 	long (*fn)(struct vfio_group *, unsigned long);
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163144 — [v4 11/16] KVM: kvm-vfio: User API for VT-d Posted-Interrupts

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 11/16] KVM: kvm-vfio: User API for VT-d Posted-Interrupts
Message-ID<pA8wW-3OV-37@gated-at.bofh.it>
In reply to#1163137
This patch adds and documents two new attributes
KVM_DEV_VFIO_DEVICE_POST_IRQ and KVM_DEV_VFIO_DEVICE_UNPOST_IRQ
in KVM_DEV_VFIO_DEVICE group. The new attributes are used for
VT-d Posted-Interrupts.

When guest OS changes the interrupt configuration for an
assigned device, such as, MSI/MSIx data/address fields,
QEMU will use this IRQ attribute to tell KVM to update the
related IRTE according the VT-d Posted-Interrrupts Specification,
such as, the guest vector should be updated in the related IRTE.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 Documentation/virtual/kvm/devices/vfio.txt | 9 +++++++++
 include/uapi/linux/kvm.h                   | 2 ++
 2 files changed, 11 insertions(+)

diff --git a/Documentation/virtual/kvm/devices/vfio.txt b/Documentation/virtual/kvm/devices/vfio.txt
index 6186e6d..34925e1 100644
--- a/Documentation/virtual/kvm/devices/vfio.txt
+++ b/Documentation/virtual/kvm/devices/vfio.txt
@@ -42,3 +42,12 @@ In such a situation, -EAGAIN is returned. It is advised to to set the
 forwarding before the VFIO signaling is set up, this avoids trial and errors.
 
 Unforwarding can happen at any time.
+
+  KVM_DEV_VFIO_DEVICE_POST_IRQ: set a VFIO device IRQ as posted
+  KVM_DEV_VFIO_DEVICE_UNPOST_IRQ: set a VFIO device IRQ as remapped
+For this attribute, kvm_device_attr.addr points to a kvm_vfio_dev_irq struct.
+
+When guest OS changes the interrupt configuration for an assigned device,
+such as, MSI/MSIx data/address fields, QEMU will use this IRQ attribute
+to tell KVM to update the related IRTE according the VT-d Posted-Interrrupts
+Specification, such as, the guest vector should be updated in the related IRTE.
diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h
index 798f3e4..6e17596 100644
--- a/include/uapi/linux/kvm.h
+++ b/include/uapi/linux/kvm.h
@@ -1002,6 +1002,8 @@ struct kvm_device_attr {
 #define  KVM_DEV_VFIO_DEVICE			2
 #define   KVM_DEV_VFIO_DEVICE_FORWARD_IRQ			1
 #define   KVM_DEV_VFIO_DEVICE_UNFORWARD_IRQ			2
+#define   KVM_DEV_VFIO_DEVICE_POST_IRQ				3
+#define   KVM_DEV_VFIO_DEVICE_UNPOST_IRQ			4
 
 enum kvm_device_type {
 	KVM_DEV_TYPE_FSL_MPIC_20	= 1,
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163146 — [v4 05/16] KVM: Add interfaces to control PI outside vmx

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 05/16] KVM: Add interfaces to control PI outside vmx
Message-ID<pA8wW-3OV-41@gated-at.bofh.it>
In reply to#1163137
This patch adds pi_clear_sn and pi_set_sn to struct kvm_x86_ops,
so we can set/clear SN outside vmx.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/include/asm/kvm_host.h |  3 +++
 arch/x86/kvm/vmx.c              | 13 +++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h
index c7a09fb..69bc770 100644
--- a/arch/x86/include/asm/kvm_host.h
+++ b/arch/x86/include/asm/kvm_host.h
@@ -835,6 +835,9 @@ struct kvm_x86_ops {
 					   gfn_t offset, unsigned long mask);
 
 	u64 (*get_pi_desc_addr)(struct kvm_vcpu *vcpu);
+
+	void (*pi_clear_sn)(struct kvm_vcpu *vcpu);
+	void (*pi_set_sn)(struct kvm_vcpu *vcpu);
 };
 
 struct kvm_arch_async_pf {
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index ccc9ce4..dd3c63a 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -615,6 +615,16 @@ struct pi_desc *vcpu_to_pi_desc(struct kvm_vcpu *vcpu)
 	return &(to_vmx(vcpu)->pi_desc);
 }
 
+static void vmx_pi_clear_sn(struct kvm_vcpu *vcpu)
+{
+	pi_clear_sn(vcpu_to_pi_desc(vcpu));
+}
+
+static void vmx_pi_set_sn(struct kvm_vcpu *vcpu)
+{
+	pi_set_sn(vcpu_to_pi_desc(vcpu));
+}
+
 static unsigned long shadow_read_only_fields[] = {
 	/*
 	 * We do NOT shadow fields that are modified when L0
@@ -10307,6 +10317,9 @@ static struct kvm_x86_ops vmx_x86_ops = {
 	.enable_log_dirty_pt_masked = vmx_enable_log_dirty_pt_masked,
 
 	.get_pi_desc_addr = vmx_get_pi_desc_addr,
+
+	.pi_clear_sn = vmx_pi_clear_sn,
+	.pi_set_sn = vmx_pi_set_sn,
 };
 
 static int __init vmx_init(void)
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163147 — [v4 14/16] KVM: Update Posted-Interrupts Descriptor when vCPU is preempted

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 14/16] KVM: Update Posted-Interrupts Descriptor when vCPU is preempted
Message-ID<pA8wW-3OV-43@gated-at.bofh.it>
In reply to#1163137
This patch updates the Posted-Interrupts Descriptor when vCPU
is preempted.

sched out:
- Set 'SN' to suppress furture non-urgent interrupts posted for
the vCPU.

sched in:
- Clear 'SN'
- Change NDST if vCPU is scheduled to a different CPU
- Set 'NV' to POSTED_INTR_VECTOR

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/kvm/vmx.c | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index dd3c63a..9d9b403 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -46,6 +46,7 @@
 #include <asm/debugreg.h>
 #include <asm/kexec.h>
 #include <asm/apic.h>
+#include <asm/irq_remapping.h>
 
 #include "trace.h"
 
@@ -2001,10 +2002,43 @@ static void vmx_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
 		vmcs_writel(HOST_IA32_SYSENTER_ESP, sysenter_esp); /* 22.2.3 */
 		vmx->loaded_vmcs->cpu = cpu;
 	}
+
+	if (irq_remapping_cap(IRQ_POSTING_CAP)) {
+		struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
+		struct pi_desc old, new;
+		unsigned int dest;
+
+		do {
+			old.control = new.control = pi_desc->control;
+			if (vcpu->cpu != cpu) {
+				dest = cpu_physical_id(cpu);
+
+				if (x2apic_enabled())
+					new.ndst = dest;
+				else
+					new.ndst = (dest << 8) & 0xFF00;
+			}
+
+			/* Allow posting non-urgent interrupts */
+			new.sn = 0;
+
+			/* set 'NV' to 'notification vector' */
+			new.nv = POSTED_INTR_VECTOR;
+		} while (cmpxchg(&pi_desc->control, old.control,
+				new.control) != old.control);
+	}
 }
 
 static void vmx_vcpu_put(struct kvm_vcpu *vcpu)
 {
+	if (irq_remapping_cap(IRQ_POSTING_CAP)) {
+		struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
+
+		/* Set SN when the vCPU is preempted */
+		if (vcpu->preempted)
+			pi_set_sn(pi_desc);
+	}
+
 	__vmx_load_host_state(to_vmx(vcpu));
 	if (!vmm_exclusive) {
 		__loaded_vmcs_clear(to_vmx(vcpu)->loaded_vmcs);
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163148 — [v4 02/16] KVM: Add some helper functions for Posted-Interrupts

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 02/16] KVM: Add some helper functions for Posted-Interrupts
Message-ID<pA8wW-3OV-45@gated-at.bofh.it>
In reply to#1163137
This patch adds some helper functions to manipulate the
Posted-Interrupts Descriptor.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/kvm/vmx.c | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index bd26501..8be6aa4 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -443,6 +443,8 @@ struct nested_vmx {
 };
 
 #define POSTED_INTR_ON  0
+#define POSTED_INTR_SN  1
+
 /* Posted-Interrupt Descriptor */
 struct pi_desc {
 	u32 pir[8];     /* Posted interrupt requested */
@@ -483,6 +485,30 @@ static int pi_test_and_set_pir(int vector, struct pi_desc *pi_desc)
 	return test_and_set_bit(vector, (unsigned long *)pi_desc->pir);
 }
 
+static void pi_clear_sn(struct pi_desc *pi_desc)
+{
+	return clear_bit(POSTED_INTR_SN,
+			(unsigned long *)&pi_desc->control);
+}
+
+static void pi_set_sn(struct pi_desc *pi_desc)
+{
+	return set_bit(POSTED_INTR_SN,
+			(unsigned long *)&pi_desc->control);
+}
+
+static int pi_test_on(struct pi_desc *pi_desc)
+{
+	return test_bit(POSTED_INTR_ON,
+			(unsigned long *)&pi_desc->control);
+}
+
+static int pi_test_sn(struct pi_desc *pi_desc)
+{
+	return test_bit(POSTED_INTR_SN,
+			(unsigned long *)&pi_desc->control);
+}
+
 struct vcpu_vmx {
 	struct kvm_vcpu       vcpu;
 	unsigned long         host_rsp;
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163149 — [v4 16/16] KVM: Warn if 'SN' is set during posting interrupts by software

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 16/16] KVM: Warn if 'SN' is set during posting interrupts by software
Message-ID<pA8wX-3OV-51@gated-at.bofh.it>
In reply to#1163137
Currently, we don't support urgent interrupt, all interrupts
are recognized as non-urgent interrupt, so we cannot post
interrupts when 'SN' is set.

If the vcpu is in guest mode, it cannot have been scheduled out,
and that's the only case when SN is set currently, warning if
SN is set.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/kvm/vmx.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index 7e8a800..f1daa8b 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -4485,6 +4485,22 @@ static inline bool kvm_vcpu_trigger_posted_interrupt(struct kvm_vcpu *vcpu)
 {
 #ifdef CONFIG_SMP
 	if (vcpu->mode == IN_GUEST_MODE) {
+		struct vcpu_vmx *vmx = to_vmx(vcpu);
+
+		/*
+		 * Currently, we don't support urgent interrupt,
+		 * all interrupts are recognized as non-urgent
+		 * interrupt, so we cannot post interrupts when
+		 * 'SN' is set.
+		 *
+		 * If the vcpu is in guest mode, it means it is
+		 * running instead of being scheduled out and
+		 * waiting in the run queue, and that's the only
+		 * case when 'SN' is set currently, warning if
+		 * 'SN' is set.
+		 */
+		WARN_ON_ONCE(pi_test_sn(&vmx->pi_desc));
+
 		apic->send_IPI_mask(get_cpu_mask(vcpu->cpu),
 				POSTED_INTR_VECTOR);
 		return true;
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163150 — [v4 04/16] KVM: Get Posted-Interrupts descriptor address from struct kvm_vcpu

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 04/16] KVM: Get Posted-Interrupts descriptor address from struct kvm_vcpu
Message-ID<pA8wX-3OV-53@gated-at.bofh.it>
In reply to#1163137
Define an interface to get PI descriptor address from the vCPU structure.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/include/asm/kvm_host.h |  2 ++
 arch/x86/kvm/vmx.c              | 11 +++++++++++
 2 files changed, 13 insertions(+)

diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h
index cab4141..c7a09fb 100644
--- a/arch/x86/include/asm/kvm_host.h
+++ b/arch/x86/include/asm/kvm_host.h
@@ -833,6 +833,8 @@ struct kvm_x86_ops {
 	void (*enable_log_dirty_pt_masked)(struct kvm *kvm,
 					   struct kvm_memory_slot *slot,
 					   gfn_t offset, unsigned long mask);
+
+	u64 (*get_pi_desc_addr)(struct kvm_vcpu *vcpu);
 };
 
 struct kvm_arch_async_pf {
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index 8be6aa4..ccc9ce4 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -610,6 +610,10 @@ static inline struct vcpu_vmx *to_vmx(struct kvm_vcpu *vcpu)
 #define FIELD64(number, name)	[number] = VMCS12_OFFSET(name), \
 				[number##_HIGH] = VMCS12_OFFSET(name)+4
 
+struct pi_desc *vcpu_to_pi_desc(struct kvm_vcpu *vcpu)
+{
+	return &(to_vmx(vcpu)->pi_desc);
+}
 
 static unsigned long shadow_read_only_fields[] = {
 	/*
@@ -4495,6 +4499,11 @@ static void vmx_sync_pir_to_irr_dummy(struct kvm_vcpu *vcpu)
 	return;
 }
 
+static u64 vmx_get_pi_desc_addr(struct kvm_vcpu *vcpu)
+{
+	return __pa((u64)vcpu_to_pi_desc(vcpu));
+}
+
 /*
  * Set up the vmcs's constant host-state fields, i.e., host-state fields that
  * will not change in the lifetime of the guest.
@@ -10296,6 +10305,8 @@ static struct kvm_x86_ops vmx_x86_ops = {
 	.slot_disable_log_dirty = vmx_slot_disable_log_dirty,
 	.flush_log_dirty = vmx_flush_log_dirty,
 	.enable_log_dirty_pt_masked = vmx_enable_log_dirty_pt_masked,
+
+	.get_pi_desc_addr = vmx_get_pi_desc_addr,
 };
 
 static int __init vmx_init(void)
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163151 — [v4 01/16] KVM: Extend struct pi_desc for VT-d Posted-Interrupts

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 01/16] KVM: Extend struct pi_desc for VT-d Posted-Interrupts
Message-ID<pA8wX-3OV-47@gated-at.bofh.it>
In reply to#1163137
Extend struct pi_desc for VT-d Posted-Interrupts.

Signed-off-by: Feng Wu <feng.wu@intel.com>
---
 arch/x86/kvm/vmx.c | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index f7b6168..bd26501 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -446,8 +446,24 @@ struct nested_vmx {
 /* Posted-Interrupt Descriptor */
 struct pi_desc {
 	u32 pir[8];     /* Posted interrupt requested */
-	u32 control;	/* bit 0 of control is outstanding notification bit */
-	u32 rsvd[7];
+	union {
+		struct {
+				/* bit 256 - Outstanding Notification */
+			u64	on	: 1,
+				/* bit 257 - Suppress Notification */
+				sn	: 1,
+				/* bit 271:258 - Reserved */
+				rsvd_1	: 14,
+				/* bit 279:272 - Notification Vector */
+				nv	: 8,
+				/* bit 287:280 - Reserved */
+				rsvd_2	: 8,
+				/* bit 319:288 - Notification Destination */
+				ndst	: 32;
+		};
+		u64 control;
+	};
+	u32 rsvd[6];
 } __aligned(64);
 
 static bool pi_test_and_set_on(struct pi_desc *pi_desc)
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1163152 — [v4 09/16] VFIO: external user API for interaction

FromFeng Wu <feng.wu@intel.com>
Date2015-06-11 13:10 +0200
Subject[v4 09/16] VFIO: external user API for interaction
Message-ID<pA8wX-3OV-49@gated-at.bofh.it>
In reply to#1163137
From: Eric Auger <eric.auger@linaro.org>

The VFIO external user API is enriched with 3 new functions that
allows a kernel user external to VFIO to retrieve some information
from a VFIO device.

- vfio_device_get_external_user enables to get a vfio device from
  its fd and increments its reference counter
- vfio_device_put_external_user decrements the reference counter
- vfio_external_base_device returns a handle to the struct device

Signed-off-by: Eric Auger <eric.auger@linaro.org>
---
 drivers/vfio/vfio.c  | 24 ++++++++++++++++++++++++
 include/linux/vfio.h |  3 +++
 2 files changed, 27 insertions(+)

diff --git a/drivers/vfio/vfio.c b/drivers/vfio/vfio.c
index e1278fe..c10b3cb 100644
--- a/drivers/vfio/vfio.c
+++ b/drivers/vfio/vfio.c
@@ -1504,6 +1504,30 @@ void vfio_group_put_external_user(struct vfio_group *group)
 }
 EXPORT_SYMBOL_GPL(vfio_group_put_external_user);
 
+struct vfio_device *vfio_device_get_external_user(struct file *filep)
+{
+	struct vfio_device *vdev = filep->private_data;
+
+	if (filep->f_op != &vfio_device_fops)
+		return ERR_PTR(-EINVAL);
+
+	vfio_device_get(vdev);
+	return vdev;
+}
+EXPORT_SYMBOL_GPL(vfio_device_get_external_user);
+
+void vfio_device_put_external_user(struct vfio_device *vdev)
+{
+	vfio_device_put(vdev);
+}
+EXPORT_SYMBOL_GPL(vfio_device_put_external_user);
+
+struct device *vfio_external_base_device(struct vfio_device *vdev)
+{
+	return vdev->dev;
+}
+EXPORT_SYMBOL_GPL(vfio_external_base_device);
+
 int vfio_external_user_iommu_id(struct vfio_group *group)
 {
 	return iommu_group_id(group->iommu_group);
diff --git a/include/linux/vfio.h b/include/linux/vfio.h
index ddb4409..e120e9a 100644
--- a/include/linux/vfio.h
+++ b/include/linux/vfio.h
@@ -88,6 +88,9 @@ extern void vfio_group_put_external_user(struct vfio_group *group);
 extern int vfio_external_user_iommu_id(struct vfio_group *group);
 extern long vfio_external_check_extension(struct vfio_group *group,
 					  unsigned long arg);
+extern struct vfio_device *vfio_device_get_external_user(struct file *filep);
+extern void vfio_device_put_external_user(struct vfio_device *vdev);
+extern struct device *vfio_external_base_device(struct vfio_device *vdev);
 
 struct pci_dev;
 #ifdef CONFIG_EEH
-- 
2.1.0

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web