Merge tag 'rolling-lts/wsl/6.18.26.2' into linux-msft-wsl-6.18.y

Linux rolling-lts/wsl/6.18.26.2

Signed-off-by: Mitchell Levy <levymitchell0@gmail.com>

Author: chessturo

MSFT-Merge/log

@@ -5,6 +5,7 @@ feature/arm64-hyperv-hypercall-interface/6.18      712c88941ba7cfd3c9eec3a58eef4
 feature/arm64-hyperv-synthetic-clocks-timers/6.18  ea0cd9a5b6202ef81b45f137c37b17478a54f382
 feature/wsl-module-script/6.18                     9c6d7c0a3fadd2ce32c90dad74429ed7e463ad4a
 feature/dxgkrnl/6.18                               7645bb43d045d813c5a11a5746c28bd763868b28
+feature/swiotlb-pool/6.18                          8e58006b40f811c1611a0edd7f8ac4f518baf1dd
 product/wsl/readme/6.18                            bbf044c25e1203bed3182cedae466235420e7e96
 product/wsl/security/6.18                          20778f3fd73f259549f66a8bea0227dbdfe3e170
 fix/virtiofs-dax-hang/6.18                         668def1339349ba0ff85f22b6244066a8369b022

Makefile

@@ -2,7 +2,7 @@
 VERSION = 6
 PATCHLEVEL = 18
 SUBLEVEL = 26
-EXTRAVERSION = .1
+EXTRAVERSION = .2
 NAME = Baby Opossum Posse
 
 # *DOCUMENTATION*

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.
  */
@@ -2510,6 +2528,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
@@ -2533,6 +2570,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;
@@ -2803,6 +2841,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;
 
@@ -4221,6 +4260,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

@@ -1898,3 +1898,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);