pv-iommu-support.patch

Author: Vates Git Importer

arch/x86/include/asm/xen/hypercall.h

@@ -51,6 +51,7 @@
 #include <xen/interface/xen.h>
 #include <xen/interface/sched.h>
 #include <xen/interface/physdev.h>
+#include <xen/interface/pv-iommu.h>
 #include <xen/interface/platform.h>
 #include <xen/interface/xen-mca.h>
 
@@ -329,6 +330,12 @@ MULTI_fpu_taskswitch(struct multicall_entry *mcl, int set)
 	trace_xen_mc_entry(mcl, 1);
 }
 
+static inline int
+HYPERVISOR_iommu_op(void *uop, unsigned int count)
+{
+       return _hypercall2(int, iommu_op, uop, count);
+}
+
 static inline void
 MULTI_update_va_mapping(struct multicall_entry *mcl, unsigned long va,
 			pte_t new_val, unsigned long flags)

arch/x86/kernel/Makefile

@@ -60,7 +60,7 @@ obj-$(CONFIG_X86_64)	+= sys_x86_64.o
 obj-$(CONFIG_X86_ESPFIX64)	+= espfix_64.o
 obj-$(CONFIG_SYSFS)	+= ksysfs.o
 obj-y			+= bootflag.o e820.o
-obj-y			+= pci-dma.o quirks.o topology.o kdebugfs.o
+obj-y			+= pci-dma.o pci-dma-xen.o quirks.o topology.o kdebugfs.o
 obj-y			+= alternative.o i8253.o hw_breakpoint.o
 obj-y			+= tsc.o tsc_msr.o io_delay.o rtc.o
 obj-y			+= resource.o

arch/x86/kernel/pci-dma-xen.c

@@ -0,0 +1,184 @@
+#include <linux/types.h>
+#include <linux/kthread.h>
+#include <asm/xen/hypercall.h>
+#include <xen/interface/memory.h>
+#include <xen/hvc-console.h>
+#include <asm/xen/page.h>
+
+#include <xen/xen.h>
+
+#define IOMMU_BATCH_SIZE 128
+
+extern unsigned long max_pfn;
+dma_addr_t pv_iommu_1_to_1_offset;
+EXPORT_SYMBOL(pv_iommu_1_to_1_offset);
+
+bool pv_iommu_1_to_1_setup_complete;
+EXPORT_SYMBOL(pv_iommu_1_to_1_setup_complete);
+
+static struct pv_iommu_op iommu_ops[IOMMU_BATCH_SIZE];
+
+int xen_iommu_map_page(unsigned long bfn, unsigned long mfn)
+{
+	struct pv_iommu_op iommu_op;
+	int rc;
+
+	iommu_op.u.map_page.bfn = bfn;
+	iommu_op.u.map_page.gfn = mfn;
+	iommu_op.flags = IOMMU_OP_readable | IOMMU_OP_writeable | IOMMU_MAP_OP_no_ref_cnt;
+	iommu_op.subop_id = IOMMUOP_map_page;
+	rc = HYPERVISOR_iommu_op(&iommu_op, 1);
+	if (rc < 0) {
+		printk("Failed to setup IOMMU mapping for gpfn 0x%lx, mfn 0x%lx, err %d\n",
+				bfn, mfn, rc);
+		return rc;
+	}
+	return iommu_op.status;
+}
+EXPORT_SYMBOL_GPL(xen_iommu_map_page);
+
+int xen_iommu_unmap_page(unsigned long bfn)
+{
+	struct pv_iommu_op iommu_op;
+	int rc;
+
+	iommu_op.u.unmap_page.bfn = bfn;
+	iommu_op.flags = IOMMU_MAP_OP_no_ref_cnt;
+	iommu_op.subop_id = IOMMUOP_unmap_page;
+	rc = HYPERVISOR_iommu_op(&iommu_op, 1);
+	if (rc < 0) {
+		printk("Failed to remove IOMMU mapping for gpfn 0x%lx, err %d\n", bfn, rc);
+		return rc;
+	}
+	return iommu_op.status;
+}
+
+int xen_iommu_batch(struct pv_iommu_op *iommu_ops, int count)
+{
+	int rc;
+
+	rc = HYPERVISOR_iommu_op(iommu_ops, count);
+	if (rc < 0) {
+		printk("Failed to batch IOMMU map, err %d\n", rc);
+	}
+	return rc;
+}
+EXPORT_SYMBOL_GPL(xen_iommu_batch);
+
+static int check_batch(int size)
+{
+	int op;
+	int res=0;
+	for (op = 1; op < size; op +=2)
+	{
+		if ( iommu_ops[op].status ) {
+			printk("Iommu op %d went wrong, subop id %d, bfn 0x%llx, gfn 0x%llx\n, err %d, flags 0x%x\n",
+			       op, iommu_ops[op].subop_id,
+			       iommu_ops[op].u.map_page.bfn,
+			       iommu_ops[op].u.map_page.gfn,
+			       iommu_ops[op].status, iommu_ops[op].flags );
+			res++;
+		}
+	}
+	return res;
+}
+
+
+void __init pci_xen_pv_iommu_late_init(void)
+{
+	if (pv_iommu_1_to_1_offset) {
+		/* Xen has already set up 1-1 mapping for us */
+		pv_iommu_1_to_1_setup_complete = true;
+		printk(KERN_INFO "XEN-PV-IOMMU - completed setting up 1-1 mapping\n");
+	}
+}
+
+/*
+ * Detect is we can use PV-IOMMU
+ * If we can, caller needs to disable xen_swiotlb.
+ * and additionally set up normal x86 swiotlb. (PV-IOMMU is layered on top)
+ * Otherwise keep xen_swiotlb & don't setup x86 one.
+ */
+
+int pci_xen_swiotlb_pviommu_detect(void)
+{
+	int count = 0;
+	u64 pfn, pfn_limit, max_host_mfn = 0;
+	struct pv_iommu_op_ext iommu_op;
+	int rc;
+
+	if (!xen_initial_domain())
+		return 0;
+
+	iommu_op.u.query_caps.offset = 0;
+	iommu_op.flags = 0;
+	iommu_op.status = 0;
+	iommu_op.subop_id = IOMMUOP_query_caps;
+	rc = HYPERVISOR_iommu_op(&iommu_op, 1);
+
+	if (rc || !(iommu_op.flags & IOMMU_QUERY_map_cap)) {
+		printk(KERN_INFO "XEN-PV-IOMMU: No IOMMU cap.\n");
+		return 0;
+	}
+
+	max_host_mfn = HYPERVISOR_memory_op(XENMEM_maximum_ram_page, NULL);
+	printk("Max host RAM MFN is 0x%llx\n",max_host_mfn);
+	printk("max_pfn is 0x%lx\n",max_pfn);
+
+	/* Check and Setup 1-1 host RAM offset location */
+	if (iommu_op.flags & IOMMU_QUERY_map_all_mfns)
+		pv_iommu_1_to_1_offset = (dma_addr_t) iommu_op.u.query_caps.offset << PAGE_SHIFT;
+	/* If offset is 0 or not set - disable PV IOMMU */
+	if (!pv_iommu_1_to_1_offset) {
+		printk(KERN_INFO "XEN-PV-IOMMU: Disabled.\n");
+		return 0;
+	}
+	pfn_limit = pv_iommu_1_to_1_offset >> PAGE_SHIFT;
+	if (max_pfn >= pfn_limit) {
+		printk("XEN-PV-IOMMU: bfn_foreign_offset at %llu, is too small"
+			" for Dom0.  Needs %lu\n", pfn_limit, max_pfn + 1);
+		BUG();
+	}
+
+	pfn_limit = min(max_host_mfn, pfn_limit);
+
+	/* Setup 1-1 mapping of GPFN to MFN */
+	for (pfn=0; pfn < pfn_limit; pfn++)
+	{
+		unsigned long mfn = get_phys_to_machine(pfn);
+		if (mfn != INVALID_P2M_ENTRY && mfn != IDENTITY_FRAME(pfn))
+		{
+			iommu_ops[count].u.unmap_page.bfn = pfn;
+			iommu_ops[count].flags = IOMMU_MAP_OP_no_ref_cnt;
+			iommu_ops[count].subop_id = IOMMUOP_unmap_page;
+			count++;
+			iommu_ops[count].u.map_page.bfn = pfn;
+			iommu_ops[count].u.map_page.gfn = pfn_to_mfn(pfn);
+			iommu_ops[count].flags = IOMMU_OP_readable |
+						IOMMU_OP_writeable |
+						IOMMU_MAP_OP_no_ref_cnt;
+			iommu_ops[count].subop_id = IOMMUOP_map_page;
+			count++;
+		}
+		if (count == IOMMU_BATCH_SIZE)
+		{
+			count = 0;
+			if (xen_iommu_batch(iommu_ops, IOMMU_BATCH_SIZE)
+			   || check_batch(IOMMU_BATCH_SIZE)) {
+				printk("Failed to fully Setup 1-1 mapping of GPFN to MFN.\n");
+				BUG();
+			}
+		}
+	}
+	if (count) {
+		if (xen_iommu_batch(iommu_ops, count)
+		   || check_batch(count)) {
+			printk("Failed to fully Setup 1-1 mapping of GPFN to MFN.\n");
+			BUG();
+		}
+	}
+
+	printk("XEN-PV-IOMMU: Using GPFN IOMMU mode, 1-to-1 offset is 0x%llx\n",
+		pv_iommu_1_to_1_offset);
+	return 1;
+}

arch/x86/kernel/pci-dma.c

@@ -18,6 +18,9 @@
 #include <xen/xen.h>
 #include <xen/swiotlb-xen.h>
 
+void pci_xen_pv_iommu_late_init(void);
+int pci_xen_swiotlb_pviommu_detect(void);
+
 static bool disable_dac_quirk __read_mostly;
 
 const struct dma_map_ops *dma_ops;
@@ -83,9 +86,13 @@ static void __init pci_xen_swiotlb_init(void)
 	if (!xen_swiotlb_enabled())
 		return;
 	x86_swiotlb_enable = true;
-	x86_swiotlb_flags |= SWIOTLB_ANY;
+	if (!pv_iommu_1_to_1_offset)
+		x86_swiotlb_flags |= SWIOTLB_ANY;
+
 	swiotlb_init_remap(true, x86_swiotlb_flags, xen_swiotlb_fixup);
-	dma_ops = &xen_swiotlb_dma_ops;
+
+	if (!pv_iommu_1_to_1_offset)
+		dma_ops = &xen_swiotlb_dma_ops;
 	if (IS_ENABLED(CONFIG_PCI))
 		pci_request_acs();
 }
@@ -98,14 +105,20 @@ static inline void __init pci_xen_swiotlb_init(void)
 void __init pci_iommu_alloc(void)
 {
 	if (xen_pv_domain()) {
+		bool pviommu = pci_xen_swiotlb_pviommu_detect();
 		pci_xen_swiotlb_init();
-		return;
+		if (!pviommu)
+			return;
 	}
 	pci_swiotlb_detect();
 	gart_iommu_hole_init();
 	amd_iommu_detect();
 	detect_intel_iommu();
 	swiotlb_init(x86_swiotlb_enable, x86_swiotlb_flags);
+	if (pv_iommu_1_to_1_offset) {
+		printk(KERN_INFO "XEN-PV-IOMMU: "
+		       "Using software bounce buffering for IO on 32bit DMA devices (SWIOTLB)\n");
+        }
 }
 
 /*
@@ -180,6 +193,9 @@ static int __init pci_iommu_init(void)
 #ifdef CONFIG_SWIOTLB
 	/* An IOMMU turned us off. */
 	if (x86_swiotlb_enable) {
+		/* if PV-IOMMU enabled, call late init too */
+		pci_xen_pv_iommu_late_init();
+
 		pr_info("PCI-DMA: Using software bounce buffering for IO (SWIOTLB)\n");
 		swiotlb_print_info();
 	} else {

arch/x86/xen/xen-head.S

@@ -181,5 +181,6 @@ SYM_FUNC_END(xen_hypercall_intel)
 		.long FEATURES_PV | FEATURES_PVH | FEATURES_DOM0)
 	ELFNOTE(Xen, XEN_ELFNOTE_LOADER,         .asciz "generic")
 	ELFNOTE(Xen, XEN_ELFNOTE_SUSPEND_CANCEL, .long 1)
+	ELFNOTE(XS, XS_ELFNOTE_PV_IOMMU, .long 1)
 
 #endif /*CONFIG_XEN */

drivers/xen/Makefile

@@ -24,6 +24,7 @@ obj-$(CONFIG_XENFS)			+= xenfs/
 obj-$(CONFIG_XEN_SYS_HYPERVISOR)	+= sys-hypervisor.o
 obj-$(CONFIG_XEN_PVHVM_GUEST)		+= platform-pci.o
 obj-$(CONFIG_SWIOTLB_XEN)		+= swiotlb-xen.o
+obj-$(CONFIG_SWIOTLB_XEN)		+= pv-iommu-xen.o
 obj-$(CONFIG_XEN_MCE_LOG)		+= mcelog.o
 obj-$(CONFIG_XEN_PCI_STUB)	        += xen-pciback/
 obj-$(CONFIG_XEN_PRIVCMD)		+= xen-privcmd.o

drivers/xen/balloon.c

@@ -74,6 +74,7 @@
 #include <xen/features.h>
 #include <xen/page.h>
 #include <xen/mem-reservation.h>
+#include <xen/swiotlb-xen.h>
 
 #undef MODULE_PARAM_PREFIX
 #define MODULE_PARAM_PREFIX "xen."
@@ -344,6 +345,17 @@ static void xen_online_page(struct page *page, unsigned int order)
 	struct page *p;
 
 	pr_debug("Online %lu pages starting at pfn 0x%lx\n", size, start_pfn);
+
+#ifdef CONFIG_XEN_HAVE_PVMMU
+	/*
+	 * Clear any existing IOMMU mappings of the BFN (== PFN) for
+	 * this page, so the correct IOMMU mapping can be created when
+	 * the page is returned.
+	 */
+	if (pv_iommu_1_to_1_offset)
+		xen_iommu_unmap_page(page_to_pfn(page));
+#endif
+
 	mutex_lock(&balloon_mutex);
 	for (i = 0; i < size; i++) {
 		p = pfn_to_page(start_pfn + i);

drivers/xen/biomerge.c

@@ -3,15 +3,24 @@
 #include <linux/export.h>
 #include <xen/xen.h>
 #include <xen/page.h>
+#include <xen/swiotlb-xen.h>
 
 /* check if @page can be merged with 'vec1' */
 bool xen_biovec_phys_mergeable(const struct bio_vec *vec1,
 			       const struct page *page)
 {
 #if XEN_PAGE_SIZE == PAGE_SIZE
-	unsigned long bfn1 = pfn_to_bfn(page_to_pfn(vec1->bv_page));
-	unsigned long bfn2 = pfn_to_bfn(page_to_pfn(page));
+	unsigned long pfn1 = page_to_pfn(vec1->bv_page);
+	unsigned long pfn2 = page_to_pfn(page);
+	unsigned long bfn1, bfn2;
 
+	if (!pv_iommu_1_to_1_offset) {
+		bfn1 = pfn_to_bfn(pfn1);
+		bfn2 = pfn_to_bfn(pfn2);
+	} else {
+		bfn1 = pfn1;
+		bfn2 = pfn2;
+	}
 	return bfn1 + PFN_DOWN(vec1->bv_offset + vec1->bv_len) == bfn2;
 #else
 	/*

drivers/xen/ioemu.c

@@ -83,4 +83,48 @@ int xen_ioemu_inject_msi(domid_t domid, uint64_t addr, uint32_t data)
 
 	return HYPERVISOR_dm_op(domid, 1, &op_buf);
 }
+
+/**
+ * xen_ioemu_map_foreign_gfn_to_bfn: Returns the BFN's corresponding to GFN's.
+ * @pv_iommu_ops: pv_iommu_ops contains the struct_ map_foreign_page
+ * that will be used for lookup for BFN.
+ * @count: count of struct pv_iommu_ops.
+ *
+ * Its a wrapper function for getting BFN from GFN using IOMMU hypercall.
+*/
+int xen_ioemu_map_foreign_gfn_to_bfn(struct pv_iommu_op *ops, int count)
+{
+	int i;
+	int rc = 0;
+	for (i = 0; i < count; i++)
+	{
+		ops[i].subop_id = IOMMUOP_lookup_foreign_page;
+		ops[i].flags |= IOMMU_OP_writeable;
+	}
+	rc = HYPERVISOR_iommu_op(ops, count);
+	return rc;
+}
+
+/**
+ * xen_ioemu_unmap_foreign_gfn_to_bfn: Unmap BFN's corresponding to GFN's.
+ * @pv_iommu_ops: pv_iommu_ops contains the struct unmap_foreign_page
+ * that will be used to unmap BFNs.
+ * @count: count of struct pv_iommu_ops.
+ *
+ * Its a wrapper function to unmap foreign GFN's to BFN's .
+*/
+int xen_ioemu_unmap_foreign_gfn_to_bfn(struct pv_iommu_op *ops, int count)
+{
+	int i;
+	int rc = 0;
+	for (i = 0; i < count; i++)
+	{
+		ops[i].subop_id = IOMMUOP_unmap_foreign_page;
+	}
+	rc = HYPERVISOR_iommu_op(ops, count);
+	return rc;
+}
+
 EXPORT_SYMBOL(xen_ioemu_inject_msi);
+EXPORT_SYMBOL(xen_ioemu_map_foreign_gfn_to_bfn);
+EXPORT_SYMBOL(xen_ioemu_unmap_foreign_gfn_to_bfn);