DMA mapping changes for SCSI core
Subsystems (6)
v2 cover DMA mapping changes for SCSI core
As reported in [0], DMA mappings whose size exceeds the IOMMU IOVA caching limit may see a big performance hit.
This series introduces a new DMA mapping API, dma_opt_mapping_size(), so that drivers may know this limit when performance is a factor in the mapping.
Robin didn't like using dma_max_mapping_size() for this [1].
The SCSI core code is modified to use this limit.
I also added a patch for libata-scsi as it does not currently honour the shost max_sectors limit.
[0] https://lore.kernel.org/linux-iommu/[email protected]/
[1] https://lore.kernel.org/linux-iommu/[email protected]/
Changes since v1:
- Relocate scsi_add_host_with_dma() dma_dev check (Reported by Dan)
- Add tags from Damien and Martin (thanks)
- note: I only added Martin's tag to the SCSI patch
John Garry (4):
dma-mapping: Add dma_opt_mapping_size()
dma-iommu: Add iommu_dma_opt_mapping_size()
scsi: core: Cap shost max_sectors according to DMA optimum mapping
limits
libata-scsi: Cap ata_device->max_sectors according to
shost->max_sectors
Documentation/core-api/dma-api.rst | 9 +++++++++ drivers/ata/libata-scsi.c | 1 + drivers/iommu/dma-iommu.c | 6 ++++++ drivers/iommu/iova.c | 5 +++++ drivers/scsi/hosts.c | 5 +++++ drivers/scsi/scsi_lib.c | 4 ---- include/linux/dma-map-ops.h | 1 + include/linux/dma-mapping.h | 5 +++++ include/linux/iova.h | 2 ++ kernel/dma/mapping.c | 12 ++++++++++++ 10 files changed, 46 insertions(+), 4 deletions(-)
Signature · 1 line
2.26.2
PATCH v2 1/4 dma-mapping: Add dma_opt_mapping_size()
Streaming DMA mapping involving an IOMMU may be much slower for larger total mapping size. This is because every IOMMU DMA mapping requires an IOVA to be allocated and freed. IOVA sizes above a certain limit are not cached, which can have a big impact on DMA mapping performance.
Provide an API for device drivers to know this "optimal" limit, such that they may try to produce mapping which don't exceed it.
--- Documentation/core-api/dma-api.rst | 9 +++++++++ include/linux/dma-map-ops.h | 1 + include/linux/dma-mapping.h | 5 +++++ kernel/dma/mapping.c | 12 ++++++++++++ 4 files changed, 27 insertions(+)
Documentation/core-api/dma-api.rst +9 -0
@@ -204,6 +204,15 @@ Returns the maximum size of a mapping for the device. The size parameter of the mapping functions like dma_map_single(), dma_map_page() and others should not be larger than the returned value. +:: + + size_t + dma_opt_mapping_size(struct device *dev); + +Returns the maximum optimal size of a mapping for the device. Mapping large +buffers may take longer so device drivers are advised to limit total DMA +streaming mappings length to the returned value. + :: bool
include/linux/dma-map-ops.h +1 -0
@@ -69,6 +69,7 @@ struct dma_map_ops {int (*dma_supported)(struct device *dev,u64 mask);u64 (*get_required_mask)(struct device *dev);size_t (*max_mapping_size)(struct device *dev); +size_t (*opt_mapping_size)(void );unsigned long (*get_merge_boundary)(struct device *dev); };
include/linux/dma-mapping.h +5 -0
@@ -144,6 +144,7 @@ int dma_set_mask(struct device *dev, u64 mask);int dma_set_coherent_mask (struct device *dev,u64 mask);u64 dma_get_required_mask (struct device *dev);size_t dma_max_mapping_size (struct device *dev); +size_t dma_opt_mapping_size (struct device *dev);bool dma_need_sync (struct device *dev,dma_addr_t dma_addr);unsigned long dma_get_merge_boundary (struct device *dev); struct sg_table *dma_alloc_noncontiguous(struct device *dev, size_t size,
@@ -266,6 +267,10 @@ static inline size_t dma_max_mapping_size(struct device *dev) {return 0 ; } +static inline size_t dma_opt_mapping_size (struct device *dev) +{ +return 0 ; +}static inline bool dma_need_sync (struct device *dev,dma_addr_t dma_addr) {return false;
kernel/dma/mapping.c +12 -0
@@ -773,6 +773,18 @@ size_t dma_max_mapping_size(struct device *dev) }EXPORT_SYMBOL_GPL (dma_max_mapping_size); +size_t dma_opt_mapping_size (struct device *dev) +{ +const struct dma_map_ops *ops =get_dma_ops (dev); +size_t size =SIZE_MAX ; + +if (ops && ops->opt_mapping_size) + size = ops->opt_mapping_size (); + +return min (dma_max_mapping_size (dev), size); +} +EXPORT_SYMBOL_GPL (dma_opt_mapping_size); +bool dma_need_sync (struct device *dev,dma_addr_t dma_addr) {const struct dma_map_ops *ops =get_dma_ops (dev);
Signature · 1 line
2.26.2
PATCH v2 2/4 dma-iommu: Add iommu_dma_opt_mapping_size()
In reply to John GarryAdd the IOMMU callback for DMA mapping API dma_opt_mapping_size(), which allows the drivers to know the optimal mapping limit and thus limit the requested IOVA lengths.
This value is based on the IOVA rcache range limit, as IOVAs allocated above this limit must always be newly allocated, which may be quite slow.
--- drivers/iommu/dma-iommu.c | 6 ++++++ drivers/iommu/iova.c | 5 +++++ include/linux/iova.h | 2 ++ 3 files changed, 13 insertions(+)
drivers/iommu/dma-iommu.c +6 -0
@@ -1442,6 +1442,11 @@ static unsigned long iommu_dma_get_merge_boundary(struct device *dev)return (1UL <<__ffs (domain->pgsize_bitmap)) -1 ; } +static size_t iommu_dma_opt_mapping_size (void ) +{ +return iova_rcache_range (); +} +static const struct dma_map_ops iommu_dma_ops = { .alloc = iommu_dma_alloc, .free = iommu_dma_free,
@@ -1462,6 +1467,7 @@ static const struct dma_map_ops iommu_dma_ops = { .map_resource = iommu_dma_map_resource, .unmap_resource = iommu_dma_unmap_resource, .get_merge_boundary = iommu_dma_get_merge_boundary, + .opt_mapping_size = iommu_dma_opt_mapping_size, };/*
drivers/iommu/iova.c +5 -0
@@ -26,6 +26,11 @@ static unsigned long iova_rcache_get(struct iova_domain *iovad,static void free_cpu_cached_iovas (unsigned int cpu,struct iova_domain *iovad);static void free_iova_rcaches (struct iova_domain *iovad); +unsigned long iova_rcache_range (void ) +{ +return PAGE_SIZE << (IOVA_RANGE_CACHE_MAX_SIZE -1 ); +} +static int iova_cpuhp_dead (unsigned int cpu,struct hlist_node *node) {struct iova_domain *iovad;
include/linux/iova.h +2 -0
@@ -79,6 +79,8 @@ static inline unsigned long iova_pfn(struct iova_domain *iovad, dma_addr_t iova)int iova_cache_get (void );void iova_cache_put (void ); +unsigned long iova_rcache_range (void ); +void free_iova (struct iova_domain *iovad,unsigned long pfn);void __free_iova (struct iova_domain *iovad,struct iova *iova); struct iova *alloc_iova(struct iova_domain *iovad, unsigned long size,
Signature · 1 line
2.26.2
Re: [PATCH v2 2/4] dma-iommu: Add iommu_dma_opt_mapping_size()
Quoted 59 lines · John Garry
Add the IOMMU callback for DMA mapping API
dma_opt_mapping_size(), which allows the drivers to know the optimal mapping limit and thus limit the requested IOVA lengths.This value is based on the IOVA rcache range limit, as IOVAs allocated above this limit must always be newly allocated, which may be quite slow.
Signed-off-by John Garry <[email protected]>--- drivers/iommu/dma-iommu.c | 6 ++++++ drivers/iommu/iova.c | 5 +++++ include/linux/iova.h | 2 ++ 3 files changed, 13 insertions(+)drivers/iommu/dma-iommu.c +6
-0@@ -1442,6 +1442,11 @@ static unsigned long iommu_dma_get_merge_boundary(struct device *dev)return (1UL <<__ffs (domain->pgsize_bitmap)) -1 ; } +static size_t iommu_dma_opt_mapping_size (void ) +{ +return iova_rcache_range (); +} +static const struct dma_map_ops iommu_dma_ops = { .alloc = iommu_dma_alloc, .free = iommu_dma_free,@@ -1462,6 +1467,7 @@ static const struct dma_map_ops iommu_dma_ops = { .map_resource = iommu_dma_map_resource, .unmap_resource = iommu_dma_unmap_resource, .get_merge_boundary = iommu_dma_get_merge_boundary, + .opt_mapping_size = iommu_dma_opt_mapping_size, };/* drivers/iommu/iova.c +5
-0@@ -26,6 +26,11 @@ static unsigned long iova_rcache_get(struct iova_domain *iovad,static void free_cpu_cached_iovas (unsigned int cpu,struct iova_domain *iovad);static void free_iova_rcaches (struct iova_domain *iovad); +unsigned long iova_rcache_range (void ) +{ +return PAGE_SIZE << (IOVA_RANGE_CACHE_MAX_SIZE -1 ); +} +static int iova_cpuhp_dead (unsigned int cpu,struct hlist_node *node) {struct iova_domain *iovad;include/linux/iova.h +0
-0
include/linux/iova.h static inline unsigned long iova_pfn(struct iova_domain *iovad, dma_addr_t iova) · line 86
Quoted 8 lines
include/linux/iova.h +2
-0@@ -79,6 +79,8 @@ static inline unsigned long iova_pfn(struct iova_domain *iovad, dma_addr_t iova)int iova_cache_get (void );void iova_cache_put (void ); +unsigned long iova_rcache_range (void ); +void free_iova (struct iova_domain *iovad,unsigned long pfn);void __free_iova (struct iova_domain *iovad,struct iova *iova); struct iova *alloc_iova(struct iova_domain *iovad, unsigned long size,
Signature · 6 lines
Damien Le Moal Western Digital Research _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v2 3/4 scsi: core: Cap shost max_sectors according to DMA optimum mapping limits
In reply to John GarryStreaming DMA mappings may be considerably slower when mappings go through an IOMMU and the total mapping length is somewhat long. This is because the IOMMU IOVA code allocates and free an IOVA for each mapping, which may affect performance.
For performance reasons set the request_queue max_sectors from dma_opt_mapping_size(), which knows this mapping limit.
In addition, the shost->max_sectors is repeatedly set for each sdev in __scsi_init_queue(). This is unnecessary, so set once when adding the host.
--- drivers/scsi/hosts.c | 5 +++++ drivers/scsi/scsi_lib.c | 4 ---- 2 files changed, 5 insertions(+), 4 deletions(-)
drivers/scsi/hosts.c +5 -0
@@ -240,6 +240,11 @@ int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev, shost->dma_dev = dma_dev; +if (dma_dev->dma_mask) { + shost->max_sectors = min_t(unsigned int, shost->max_sectors, +dma_opt_mapping_size (dma_dev) >>SECTOR_SHIFT ); + } +/* * Increase usage count temporarily here so that calling * scsi_autopm_put_host() will trigger runtime idle if there is
drivers/scsi/scsi_lib.c +0 -4
@@ -1884,10 +1884,6 @@ void __scsi_init_queue(struct Scsi_Host *shost, struct request_queue *q)blk_queue_max_integrity_segments (q, shost->sg_prot_tablesize); } -if (dev->dma_mask) { - shost->max_sectors = min_t(unsigned int, shost->max_sectors, -dma_max_mapping_size (dev) >>SECTOR_SHIFT ); - }blk_queue_max_hw_sectors (q, shost->max_sectors);blk_queue_segment_boundary (q, shost->dma_boundary);dma_set_seg_boundary (dev, shost->dma_boundary);
Signature · 6 lines
2.26.2 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v2 4/4 libata-scsi: Cap ata_device->max_sectors according to shost->max_sectors
In reply to John GarryATA devices (struct ata_device) have a max_sectors field which is configured internally in libata. This is then used to (re)configure the associated sdev request queue max_sectors value from how it is earlier set in __scsi_init_queue(). In __scsi_init_queue() the max_sectors value is set according to shost limits, which includes host DMA mapping limits.
Cap the ata_device max_sectors according to shost->max_sectors to respect this shost limit.
--- drivers/ata/libata-scsi.c | 1 + 1 file changed, 1 insertion(+)
drivers/ata/libata-scsi.c +1 -0
@@ -1036,6 +1036,7 @@ int ata_scsi_dev_config(struct scsi_device *sdev, struct ata_device *dev) dev->flags |=ATA_DFLAG_NO_UNLOAD ;/* configure max sectors */ + dev->max_sectors =min (dev->max_sectors, sdev->host->max_sectors);blk_queue_max_hw_sectors (q, dev->max_sectors);if (dev->class ==ATA_DEV_ATAPI ) {
Signature · 6 lines
2.26.2 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu