Add a callback-based iterator that walks a PCI device's host bridge MMIO windows and invokes a caller-supplied function with each window's bus address range. This consolidates the bridge window enumeration logic into a single shared algorithm in the IOMMU core. Refactor iova_reserve_pci_windows() to use the new iterator, replacing its open-coded resource_list_for_each_entry loop. The callback approach avoids intermediate allocations: the DMA path's callback directly calls reserve_iova() with the computed PFN range, maintaining the same zero-allocation overhead as the original open-coded loop. Using a callback rather than returning a linked list of iommu_resv_region entries eliminates size_t truncation risk on 32-bit PAE systems (the callback receives phys_addr_t start/end directly) and removes the need for allocation failure cleanup paths. Note: commit cd2c9fcf5c66 ("iommu/dma: Move PCI window region reservation back into dma specific path.") intentionally keeps PCI window reservation out of the IOMMU group-level reserved region API. This iterator respects that boundary: it does not inject windows into iommu_get_group_resv_regions(). Signed-off-by: Guanghui Feng --- drivers/iommu/dma-iommu.c | 29 ++++++++++++++++------ drivers/iommu/iommu-priv.h | 25 +++++++++++++++++++ drivers/iommu/iommu.c | 51 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 97 insertions(+), 8 deletions(-) diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c index 68ee57800fef..d4e4a4c90d8b 100644 --- a/drivers/iommu/dma-iommu.c +++ b/drivers/iommu/dma-iommu.c @@ -37,6 +37,7 @@ #include "dma-iommu.h" #include "iommu-pages.h" +#include "iommu-priv.h" struct iommu_dma_msi_page { struct list_head list; @@ -504,6 +505,20 @@ static int iommu_dma_ranges_sort(void *priv, const struct list_head *a, return res_a->res->start > res_b->res->start; } +struct iova_pci_resv_data { + struct iova_domain *iovad; +}; + +static int iova_reserve_pci_window_fn(phys_addr_t start, phys_addr_t end, + void *data) +{ + struct iova_pci_resv_data *d = data; + + reserve_iova(d->iovad, iova_pfn(d->iovad, start), + iova_pfn(d->iovad, end)); + return 0; +} + static int iova_reserve_pci_windows(struct pci_dev *dev, struct iova_domain *iovad) { @@ -511,15 +526,13 @@ static int iova_reserve_pci_windows(struct pci_dev *dev, struct resource_entry *window; unsigned long lo, hi; phys_addr_t start = 0, end; + struct iova_pci_resv_data data = { .iovad = iovad }; + int ret; - resource_list_for_each_entry(window, &bridge->windows) { - if (resource_type(window->res) != IORESOURCE_MEM) - continue; - - lo = iova_pfn(iovad, window->res->start - window->offset); - hi = iova_pfn(iovad, window->res->end - window->offset); - reserve_iova(iovad, lo, hi); - } + ret = iommu_for_each_pci_mmio_window(dev, iova_reserve_pci_window_fn, + &data); + if (ret) + return ret; /* Get reserved DMA windows from host bridge */ list_sort(NULL, &bridge->dma_ranges, iommu_dma_ranges_sort); diff --git a/drivers/iommu/iommu-priv.h b/drivers/iommu/iommu-priv.h index aaffad5854fc..36a2e4691455 100644 --- a/drivers/iommu/iommu-priv.h +++ b/drivers/iommu/iommu-priv.h @@ -123,4 +123,29 @@ static inline void iommu_debug_init(void) #endif /* CONFIG_IOMMU_DEBUG_PAGEALLOC */ +struct pci_dev; + +/** + * iommu_pci_mmio_window_fn_t - callback for host bridge MMIO window iteration + * @start: First PCI bus address of the window (inclusive) + * @end: Last PCI bus address of the window (inclusive) + * @data: Opaque pointer from iommu_for_each_pci_mmio_window() caller + * + * Return: 0 to continue iteration, negative errno to stop and propagate. + */ +typedef int (*iommu_pci_mmio_window_fn_t)(phys_addr_t start, phys_addr_t end, + void *data); + +#ifdef CONFIG_PCI +int iommu_for_each_pci_mmio_window(struct pci_dev *dev, + iommu_pci_mmio_window_fn_t fn, void *data); +#else +static inline int iommu_for_each_pci_mmio_window(struct pci_dev *dev, + iommu_pci_mmio_window_fn_t fn, + void *data) +{ + return 0; +} +#endif /* CONFIG_PCI */ + #endif /* __LINUX_IOMMU_PRIV_H */ diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c index cd1bca7ede9a..ec66118d13e9 100644 --- a/drivers/iommu/iommu.c +++ b/drivers/iommu/iommu.c @@ -945,6 +945,57 @@ iommu_insert_device_resv_regions(struct list_head *dev_resv_regions, return ret; } +#ifdef CONFIG_PCI +/** + * iommu_for_each_pci_mmio_window - iterate over PCI host bridge MMIO windows + * @dev: PCI device whose host bridge to scan + * @fn: callback invoked with each window's bus address range + * @data: opaque pointer passed to @fn + * + * Walks the MEM windows of @dev's PCI host bridge and invokes + * @fn(start, end, data) for each one, where start and end are PCI bus + * addresses (inclusive). Iteration stops early if @fn returns non-zero, + * and that value is propagated to the caller. + * + * This provides a zero-allocation way for both the DMA IOVA layer and + * iommufd to enumerate the same host bridge window information using a + * shared algorithm. + * + * Note: commit cd2c9fcf5c66 ("iommu/dma: Move PCI window region reservation back into dma specific path.") + * intentionally keeps PCI window reservation out of the IOMMU group-level + * reserved region API. This iterator respects that boundary: it does not + * inject windows into iommu_get_group_resv_regions(). + * + * Return: 0 on success, negative errno on failure (including from @fn). + */ +int iommu_for_each_pci_mmio_window(struct pci_dev *dev, + iommu_pci_mmio_window_fn_t fn, void *data) +{ + struct pci_host_bridge *bridge = pci_find_host_bridge(dev->bus); + struct resource_entry *window; + + if (!bridge) + return -ENODEV; + + resource_list_for_each_entry(window, &bridge->windows) { + phys_addr_t start, end; + int ret; + + if (resource_type(window->res) != IORESOURCE_MEM) + continue; + + start = window->res->start - window->offset; + end = window->res->end - window->offset; + + ret = fn(start, end, data); + if (ret) + return ret; + } + return 0; +} +EXPORT_SYMBOL_GPL(iommu_for_each_pci_mmio_window); +#endif /* CONFIG_PCI */ + int iommu_get_group_resv_regions(struct iommu_group *group, struct list_head *head) { -- 2.43.7