swiotlb, hyperv: add dedicated swiotlb pool for Hyper-V VPCI devices

Add swiotlb_create_pool(), a new API that creates a standalone swiotlb
bounce buffer pool backed by a caller-specified physical memory region.
This is similar to CONFIG_DMA_RESTRICTED_POOL but does not require
Device Tree or OF support.

Use this in the Hyper-V PCI frontend driver (pci-hyperv) to allow
dedicating a specific RAM region for streaming DMA bounce buffering of
all VPCI devices.  This is useful when VPCI devices can only DMA via a
specific portion of guest RAM determined at boot time.

The pool is configured via the hv_pci module parameter 'swiotlb', and
the corresponding memory must be reserved so the kernel does not use it
for general allocations.  This is done with a command line parameter as
shown in the example below. The 'swiotlb=force' is added to enable the
use of swiotlb.

Sample kernel command line:

    swiotlb=force hv_pci_swiotlb=0x100000000,64M

This reserves 64MB at the 4GB mark and directs the Hyper-V PCI driver
to create a swiotlb pool there.  All VPCI devices will then bounce
their streaming DMA through that region.  Coherent DMA allocations
(dma_alloc_coherent) are not affected and continue to use normal memory.

Author: asherkariv

drivers/pci/controller/pci-hyperv.c

@@ -52,6 +52,8 @@
 #include <linux/acpi.h>
 #include <linux/sizes.h>
 #include <linux/of_irq.h>
+#include <linux/swiotlb.h>
+#include <linux/memblock.h>
 #include <asm/mshyperv.h>
 
 /*
@@ -468,6 +470,22 @@ struct pci_eject_response {
 
 static int pci_ring_size = VMBUS_RING_SIZE(SZ_16K);
 
+static phys_addr_t hv_pci_swiotlb_base;
+static size_t hv_pci_swiotlb_size;
+
+static int __init early_hv_pci_swiotlb(char *p)
+{
+    hv_pci_swiotlb_base = memparse(p, &p);
+    if (*p == ',')
+        hv_pci_swiotlb_size = memparse(p + 1, NULL);
+    if (hv_pci_swiotlb_base && hv_pci_swiotlb_size)
+        memblock_reserve(hv_pci_swiotlb_base, hv_pci_swiotlb_size);
+    return 0;
+}
+early_param("hv_pci_swiotlb", early_hv_pci_swiotlb);
+
+static struct io_tlb_mem *hv_pci_swiotlb_pool;
+
 /*
  * Driver specific state.
  */
@@ -2502,6 +2520,25 @@ static void hv_pci_assign_numa_node(struct hv_pcibus_device *hbus)
 	}
 }
 
+/**
+ * hv_pci_assign_swiotlb() - assign dedicated swiotlb pool to bus devices
+ * @bus:	PCI bus whose devices should use the pool
+ *
+ * If a dedicated swiotlb pool was configured via hv_pci_swiotlb=,
+ * assign it to every device on the bus so their DMA bounce buffering
+ * uses the restricted region.
+ */
+static void hv_pci_assign_swiotlb(struct pci_bus *bus)
+{
+	struct pci_dev *dev;
+
+	if (!hv_pci_swiotlb_pool)
+		return;
+
+	list_for_each_entry(dev, &bus->devices, bus_list)
+		dev->dev.dma_io_tlb_mem = hv_pci_swiotlb_pool;
+}
+
 /**
  * create_root_hv_pci_bus() - Expose a new root PCI bus
  * @hbus:	Root PCI bus, as understood by this driver
@@ -2525,6 +2562,7 @@ static int create_root_hv_pci_bus(struct hv_pcibus_device *hbus)
 	hv_pci_assign_numa_node(hbus);
 	pci_bus_assign_resources(bridge->bus);
 	hv_pci_assign_slots(hbus);
+	hv_pci_assign_swiotlb(bridge->bus);
 	pci_bus_add_devices(bridge->bus);
 	pci_unlock_rescan_remove();
 	hbus->state = hv_pcibus_installed;
@@ -2795,6 +2833,7 @@ static void pci_devices_present_work(struct work_struct *work)
 		pci_scan_child_bus(hbus->bridge->bus);
 		hv_pci_assign_numa_node(hbus);
 		hv_pci_assign_slots(hbus);
+		hv_pci_assign_swiotlb(hbus->bridge->bus);
 		pci_unlock_rescan_remove();
 		break;
 
@@ -4213,6 +4252,17 @@ static int __init init_hv_pci_drv(void)
 	if (hv_root_partition() && !hv_nested)
 		return -ENODEV;
 
+	if (hv_pci_swiotlb_base && hv_pci_swiotlb_size) {
+		hv_pci_swiotlb_pool = swiotlb_create_pool(hv_pci_swiotlb_base,
+							   hv_pci_swiotlb_size,
+							   "hv-pci-swiotlb");
+		if (IS_ERR(hv_pci_swiotlb_pool)) {
+			pr_err("hv_pci: failed to create swiotlb pool: %ld\n",
+			       PTR_ERR(hv_pci_swiotlb_pool));
+			hv_pci_swiotlb_pool = NULL;
+		}
+	}
+
 	ret = hv_pci_irqchip_init();
 	if (ret)
 		return ret;

include/linux/swiotlb.h

@@ -185,6 +185,8 @@ bool is_swiotlb_active(struct device *dev);
 void __init swiotlb_adjust_size(unsigned long size);
 phys_addr_t default_swiotlb_base(void);
 phys_addr_t default_swiotlb_limit(void);
+struct io_tlb_mem *swiotlb_create_pool(phys_addr_t base, size_t size,
+				       const char *name);
 #else
 static inline void swiotlb_init(bool addressing_limited, unsigned int flags)
 {

kernel/dma/swiotlb.c

@@ -1881,3 +1881,67 @@ static int __init rmem_swiotlb_setup(struct reserved_mem *rmem)
 
 RESERVEDMEM_OF_DECLARE(dma, "restricted-dma-pool", rmem_swiotlb_setup);
 #endif /* CONFIG_DMA_RESTRICTED_POOL */
+
+/**
+ * swiotlb_create_pool() - create a swiotlb pool from a physical memory region
+ * @base:	Physical base address of the region.
+ * @size:	Size of the region in bytes.
+ * @name:	Name for debugfs (may be NULL).
+ *
+ * Allocates and initializes an io_tlb_mem with its default pool backed by the
+ * caller-provided physical memory.  The region must already be reserved (e.g.
+ * via memblock_reserve or firmware memory map) and within the linear mapping.
+ *
+ * The returned pool has force_bounce set so that streaming DMA is bounced
+ * through this region.  Assign it to dev->dma_io_tlb_mem to direct a device's
+ * DMA bounce buffering into this region.  Coherent DMA allocations
+ * (dma_alloc_coherent) are not affected and will use normal memory.
+ *
+ * Return: pointer to a new io_tlb_mem on success, ERR_PTR on failure.
+ */
+struct io_tlb_mem *swiotlb_create_pool(phys_addr_t base, size_t size,
+				       const char *name)
+{
+	struct io_tlb_mem *mem;
+	struct io_tlb_pool *pool;
+	unsigned long nslabs = size >> IO_TLB_SHIFT;
+	unsigned int nareas = 1;
+
+	if (PageHighMem(pfn_to_page(PHYS_PFN(base))))
+		return ERR_PTR(-EINVAL);
+
+	mem = kzalloc(sizeof(*mem), GFP_KERNEL);
+	if (!mem)
+		return ERR_PTR(-ENOMEM);
+	pool = &mem->defpool;
+
+	pool->slots = kcalloc(nslabs, sizeof(*pool->slots), GFP_KERNEL);
+	if (!pool->slots) {
+		kfree(mem);
+		return ERR_PTR(-ENOMEM);
+	}
+
+	pool->areas = kcalloc(nareas, sizeof(*pool->areas), GFP_KERNEL);
+	if (!pool->areas) {
+		kfree(pool->slots);
+		kfree(mem);
+		return ERR_PTR(-ENOMEM);
+	}
+
+	set_memory_decrypted((unsigned long)phys_to_virt(base),
+			     size >> PAGE_SHIFT);
+	swiotlb_init_io_tlb_pool(pool, base, nslabs, false, nareas);
+	mem->force_bounce = true;
+	mem->for_alloc = false;
+#ifdef CONFIG_SWIOTLB_DYNAMIC
+	spin_lock_init(&mem->lock);
+	INIT_LIST_HEAD_RCU(&mem->pools);
+#endif
+	add_mem_pool(mem, pool);
+	swiotlb_create_debugfs_files(mem, name ?: "swiotlb-pool");
+
+	pr_info("created restricted pool at %pa, size %zuMiB\n",
+		&base, size / SZ_1M);
+	return mem;
+}
+EXPORT_SYMBOL_GPL(swiotlb_create_pool);