All of lore.kernel.org
 help / color / mirror / Atom feed
From: Karol Wachowski <karol.wachowski@linux.intel.com>
To: "Alistair Popple" <apopple@nvidia.com>,
	"Christian König" <christian.koenig@amd.com>,
	"Sumit Semwal" <sumit.semwal@linaro.org>,
	"Thomas Hellström" <thomas.hellstrom@linux.intel.com>,
	"Simona Vetter" <simona.vetter@ffwll.ch>,
	"Matthew Brost" <matthew.brost@intel.com>,
	"Vivek Kasireddy" <vivek.kasireddy@intel.com>,
	"Dongwon Kim" <dongwon.kim@intel.com>,
	"Kevin Tian" <kevin.tian@intel.com>,
	"Xu Yilun" <yilun.xu@linux.intel.com>,
	"Karl Mehltretter" <kmehltretter@gmail.com>,
	"Baolu Lu" <baolu.lu@linux.intel.com>,
	"Felix Kuehling" <felix.kuehling@amd.com>,
	"Alex Deucher" <alexander.deucher@amd.com>,
	linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org,
	intel-xe@lists.freedesktop.org, amd-gfx@lists.freedesktop.org,
	linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org,
	linux-rdma@vger.kernel.org, iommu@lists.linux.dev,
	"Keith Busch" <kbusch@kernel.org>, "Jens Axboe" <axboe@kernel.dk>,
	"Christoph Hellwig" <hch@lst.de>,
	"Sagi Grimberg" <sagi@grimberg.me>,
	linux-nvme@lists.infradead.org,
	"David S. Miller" <davem@davemloft.net>,
	"Eric Dumazet" <edumazet@kernel.org>,
	"Jakub Kicinski" <kuba@kernel.org>,
	"Paolo Abeni" <pabeni@redhat.com>,
	"Simon Horman" <horms@kernel.org>,
	"Mina Almasry" <almasrymina@google.com>,
	netdev@vger.kernel.org, "Alexey Kardashevskiy" <aik@amd.com>,
	zhipingz@meta.com, treding@nvidia.com, jhubbard@nvidia.com,
	chaitanyak@nvidia.com, "Jason Gunthorpe" <jgg@ziepe.ca>,
	"Leon Romanovsky" <leon@kernel.org>
Subject: Re: [PATCH v3 07/24] dma-buf: Convert exporters allocating a table per map to the SGT mapping type
Date: Fri, 20 Nov 2026 10:02:27 +0100	[thread overview]
Message-ID: <47f2ff46-1837-43f5-a413-0dbf29716d7a@linux.intel.com> (raw)
In-Reply-To: <20261120-dma_mapping_type_v4-v3-7-c0183a409bdf@nvidia.com>

On 20-Nov-26 6:55, Alistair Popple wrote:
> These exporters allocate a struct sg_table in map_dma_buf() and free
> it again in unmap_dma_buf().
> 
> The conversion is mechanical and no behaviour change is expected.
> Instead of map_dma_buf() allocating a sg_table it instead allocates and
> returns a dma_buf_sgt_mapping, which the unmap callbacks also take.
> 
> As a side effect this fixes a leak in fsl_asrc_m2m. Its unmap_dma_buf()
> only DMA unmapped the per-map table and never freed it. It now frees the
> mapping including the table.
> 
> Co-developed-by: Jason Gunthorpe <jgg@nvidia.com>
> Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
> Signed-off-by: Alistair Popple <apopple@nvidia.com>
> ---
>   drivers/accel/amdxdna/amdxdna_cbuf.c             | 30 ++++++++------
>   drivers/accel/amdxdna/amdxdna_ubuf.c             | 34 +++++++++-------
>   drivers/accel/habanalabs/common/memory.c         | 52 +++++++++++++-----------
>   drivers/gpu/drm/armada/armada_gem.c              | 36 +++++++++-------
>   drivers/gpu/drm/i915/gem/selftests/mock_dmabuf.c | 30 ++++++++------
>   drivers/gpu/drm/tegra/gem.c                      | 30 ++++++++------
>   samples/vfio-mdev/mbochs.c                       | 31 ++++++++------
>   sound/soc/fsl/fsl_asrc_m2m.c                     | 32 +++++++++------
>   8 files changed, 161 insertions(+), 114 deletions(-)
> 
> diff --git a/drivers/accel/amdxdna/amdxdna_cbuf.c b/drivers/accel/amdxdna/amdxdna_cbuf.c
> index a504560aae98..945436516cc6 100644
> --- a/drivers/accel/amdxdna/amdxdna_cbuf.c
> +++ b/drivers/accel/amdxdna/amdxdna_cbuf.c
> @@ -5,6 +5,7 @@
>   
>   #include <drm/drm_mm.h>
>   #include <drm/drm_prime.h>
> +#include <linux/dma-buf-mapping.h>
>   
>   #include "amdxdna_cbuf.h"
>   #include "amdxdna_pci_drv.h"
> @@ -81,11 +82,13 @@ struct amdxdna_cbuf_priv {
>   	struct drm_mm_node node;
>   };
>   
> -static struct sg_table *amdxdna_cbuf_map(struct dma_buf_attachment *attach,
> -					 enum dma_data_direction direction)
> +static struct dma_buf_sgt_mapping *
> +amdxdna_cbuf_map(struct dma_buf_attachment *attach,
> +		 enum dma_data_direction direction)
>   {
>   	struct amdxdna_cbuf_priv *cbuf = attach->dmabuf->priv;
> -	struct device *dev = attach->dev;
> +	struct device *dev = dma_buf_sgt_dma_device(attach);
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct scatterlist *sgl, *sg;
>   	int ret, n_entries, i;
>   	struct sg_table *sgt;
> @@ -93,9 +96,10 @@ static struct sg_table *amdxdna_cbuf_map(struct dma_buf_attachment *attach,
>   	size_t dma_size;
>   	size_t max_seg;
>   
> -	sgt = kzalloc_obj(*sgt);
> -	if (!sgt)
> +	mapping = kzalloc_obj(*mapping);
> +	if (!mapping)
>   		return ERR_PTR(-ENOMEM);
> +	sgt = &mapping->sgt;
>   
>   	max_seg = min_t(size_t, UINT_MAX, dma_max_mapping_size(dev));
>   	n_entries = (cbuf->node.size + max_seg - 1) / max_seg;
> @@ -127,24 +131,27 @@ static struct sg_table *amdxdna_cbuf_map(struct dma_buf_attachment *attach,
>   		dma_size -= len;
>   	}
>   
> -	return sgt;
> +	return mapping;
>   
>   free_sgl:
>   	kfree(sgl);
>   free_sgt:
> -	kfree(sgt);
> +	kfree(mapping);
>   	return ERR_PTR(ret);
>   }
>   
>   static void amdxdna_cbuf_unmap(struct dma_buf_attachment *attach,
> -			       struct sg_table *sgt,
> +			       struct dma_buf_sgt_mapping *mapping,
>   			       enum dma_data_direction direction)
>   {
> -	dma_unmap_resource(attach->dev, sg_dma_address(sgt->sgl),
> +	struct sg_table *sgt = &mapping->sgt;
> +
> +	dma_unmap_resource(dma_buf_sgt_mapping_dma_device(mapping),
> +			   sg_dma_address(sgt->sgl),
>   			   drm_prime_get_contiguous_size(sgt), direction,
>   			   DMA_ATTR_SKIP_CPU_SYNC);
>   	sg_free_table(sgt);
> -	kfree(sgt);
> +	kfree(mapping);
>   }
>   
>   static void amdxdna_cbuf_release(struct dma_buf *dbuf)
> @@ -210,12 +217,11 @@ static void amdxdna_cbuf_vunmap(struct dma_buf *dbuf, struct iosys_map *map)
>   }
>   
>   static const struct dma_buf_ops amdxdna_cbuf_dmabuf_ops = {
> -	.map_dma_buf = amdxdna_cbuf_map,
> -	.unmap_dma_buf = amdxdna_cbuf_unmap,
>   	.release = amdxdna_cbuf_release,
>   	.mmap = amdxdna_cbuf_mmap,
>   	.vmap = amdxdna_cbuf_vmap,
>   	.vunmap = amdxdna_cbuf_vunmap,
> +	DMA_BUF_SIMPLE_SGT_EXP_MATCH(amdxdna_cbuf_map, amdxdna_cbuf_unmap),
>   };
>   
>   static int amdxdna_cbuf_clear(struct dma_buf *dbuf)
> diff --git a/drivers/accel/amdxdna/amdxdna_ubuf.c b/drivers/accel/amdxdna/amdxdna_ubuf.c
> index 0e0cd69cd1fb..ed8b0ab9e554 100644
> --- a/drivers/accel/amdxdna/amdxdna_ubuf.c
> +++ b/drivers/accel/amdxdna/amdxdna_ubuf.c
> @@ -7,6 +7,7 @@
>   #include <drm/drm_device.h>
>   #include <drm/drm_print.h>
>   #include <linux/dma-buf.h>
> +#include <linux/dma-buf-mapping.h>
>   #include <linux/overflow.h>
>   #include <linux/pagemap.h>
>   #include <linux/vmalloc.h>
> @@ -20,42 +21,48 @@ struct amdxdna_ubuf_priv {
>   	struct mm_struct *mm;
>   };
>   
> -static struct sg_table *amdxdna_ubuf_map(struct dma_buf_attachment *attach,
> -					 enum dma_data_direction direction)
> +static struct dma_buf_sgt_mapping *
> +amdxdna_ubuf_map(struct dma_buf_attachment *attach,
> +		 enum dma_data_direction direction)
>   {
>   	struct amdxdna_ubuf_priv *ubuf = attach->dmabuf->priv;
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct sg_table *sg;
>   	int ret;
>   
> -	sg = kzalloc_obj(*sg);
> -	if (!sg)
> +	mapping = kzalloc_obj(*mapping);
> +	if (!mapping)
>   		return ERR_PTR(-ENOMEM);
> +	sg = &mapping->sgt;
>   
>   	ret = sg_alloc_table_from_pages(sg, ubuf->pages, ubuf->nr_pages, 0,
>   					ubuf->nr_pages << PAGE_SHIFT, GFP_KERNEL);
>   	if (ret)
> -		goto err_free_sg;
> +		goto err_free_mapping;
>   
> -	ret = dma_map_sgtable(attach->dev, sg, direction, 0);
> +	ret = dma_map_sgtable(dma_buf_sgt_dma_device(attach), sg, direction, 0);
>   	if (ret)
>   		goto err_free_table;
>   
> -	return sg;
> +	return mapping;
>   
>   err_free_table:
>   	sg_free_table(sg);
> -err_free_sg:
> -	kfree(sg);
> +err_free_mapping:
> +	kfree(mapping);
>   	return ERR_PTR(ret);
>   }
>   
>   static void amdxdna_ubuf_unmap(struct dma_buf_attachment *attach,
> -			       struct sg_table *sg,
> +			       struct dma_buf_sgt_mapping *mapping,
>   			       enum dma_data_direction direction)
>   {
> -	dma_unmap_sgtable(attach->dev, sg, direction, 0);
> +	struct sg_table *sg = &mapping->sgt;
> +
> +	dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping), sg,
> +			  direction, 0);
>   	sg_free_table(sg);
> -	kfree(sg);
> +	kfree(mapping);
>   }
>   
>   static void amdxdna_ubuf_release(struct dma_buf *dbuf)
> @@ -70,9 +77,8 @@ static void amdxdna_ubuf_release(struct dma_buf *dbuf)
>   }
>   
>   static const struct dma_buf_ops amdxdna_ubuf_dmabuf_ops = {
> -	.map_dma_buf = amdxdna_ubuf_map,
> -	.unmap_dma_buf = amdxdna_ubuf_unmap,
>   	.release = amdxdna_ubuf_release,
> +	DMA_BUF_SIMPLE_SGT_EXP_MATCH(amdxdna_ubuf_map, amdxdna_ubuf_unmap),
>   };
>   
>   struct dma_buf *amdxdna_get_ubuf(struct drm_device *dev,
> diff --git a/drivers/accel/habanalabs/common/memory.c b/drivers/accel/habanalabs/common/memory.c
> index 361cff577381..fc39ccd6f8db 100644
> --- a/drivers/accel/habanalabs/common/memory.c
> +++ b/drivers/accel/habanalabs/common/memory.c
> @@ -9,6 +9,7 @@
>   #include "habanalabs.h"
>   #include "../include/hw_ip/mmu/mmu_general.h"
>   
> +#include <linux/dma-buf-mapping.h>
>   #include <linux/uaccess.h>
>   #include <linux/slab.h>
>   #include <linux/vmalloc.h>
> @@ -1531,13 +1532,15 @@ static int set_dma_sg(struct scatterlist *sg, u64 bar_address, u64 chunk_size,
>   	return 0;
>   }
>   
> -static struct sg_table *alloc_sgt_from_device_pages(struct hl_device *hdev, u64 *pages, u64 npages,
> -						u64 page_size, u64 exported_size, u64 offset,
> -						struct device *dev, enum dma_data_direction dir)
> +static struct dma_buf_sgt_mapping *
> +alloc_sgt_from_device_pages(struct hl_device *hdev, u64 *pages, u64 npages, u64 page_size,
> +			    u64 exported_size, u64 offset, struct device *dev,
> +			    enum dma_data_direction dir)
>   {
>   	u64 dma_max_seg_size, curr_page, size, chunk_size, left_size_to_export, left_size_in_page,
>   		left_size_in_dma_seg, device_address, bar_address, start_page;
>   	struct asic_fixed_properties *prop = &hdev->asic_prop;
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct scatterlist *sg;
>   	unsigned int nents, i;
>   	struct sg_table *sgt;
> @@ -1553,9 +1556,10 @@ static struct sg_table *alloc_sgt_from_device_pages(struct hl_device *hdev, u64
>   		return ERR_PTR(-EINVAL);
>   	}
>   
> -	sgt = kzalloc_obj(*sgt);
> -	if (!sgt)
> +	mapping = kzalloc_obj(*mapping);
> +	if (!mapping)
>   		return ERR_PTR(-ENOMEM);
> +	sgt = &mapping->sgt;
>   
>   	/* Use the offset to move to the actual first page that is exported */
>   	for (start_page = 0 ; start_page < npages ; ++start_page) {
> @@ -1686,7 +1690,7 @@ static struct sg_table *alloc_sgt_from_device_pages(struct hl_device *hdev, u64
>   			"SG entry %d: address %#llx, length %#x\n",
>   			i, sg_dma_address(sg), sg_dma_len(sg));
>   
> -	return sgt;
> +	return mapping;
>   
>   err_unmap:
>   	for_each_sgtable_dma_sg(sgt, sg, i) {
> @@ -1700,7 +1704,7 @@ static struct sg_table *alloc_sgt_from_device_pages(struct hl_device *hdev, u64
>   	sg_free_table(sgt);
>   
>   err_free_sgt:
> -	kfree(sgt);
> +	kfree(mapping);
>   	return ERR_PTR(rc);
>   }
>   
> @@ -1714,22 +1718,22 @@ static int hl_dmabuf_attach(struct dma_buf *dmabuf,
>   	hl_dmabuf = dmabuf->priv;
>   	hdev = hl_dmabuf->ctx->hdev;
>   
> -	rc = pci_p2pdma_distance(hdev->pdev, attachment->dev, true);
> +	rc = pci_p2pdma_distance(hdev->pdev, dma_buf_sgt_dma_device(attachment), true);
>   
>   	if (rc < 0)
>   		attachment->peer2peer = false;
>   	return 0;
>   }
>   
> -static struct sg_table *hl_map_dmabuf(struct dma_buf_attachment *attachment,
> -					enum dma_data_direction dir)
> +static struct dma_buf_sgt_mapping *
> +hl_map_dmabuf(struct dma_buf_attachment *attachment, enum dma_data_direction dir)
>   {
>   	u64 *pages, npages, page_size, exported_size, offset;
>   	struct dma_buf *dma_buf = attachment->dmabuf;
>   	struct hl_vm_phys_pg_pack *phys_pg_pack;
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct hl_dmabuf_priv *hl_dmabuf;
>   	struct hl_device *hdev;
> -	struct sg_table *sgt;
>   
>   	hl_dmabuf = dma_buf->priv;
>   	hdev = hl_dmabuf->ctx->hdev;
> @@ -1753,18 +1757,21 @@ static struct sg_table *hl_map_dmabuf(struct dma_buf_attachment *attachment,
>   		page_size = hl_dmabuf->dmabuf->size;
>   	}
>   
> -	sgt = alloc_sgt_from_device_pages(hdev, pages, npages, page_size, exported_size, offset,
> -						attachment->dev, dir);
> -	if (IS_ERR(sgt))
> -		dev_err(hdev->dev, "failed (%ld) to initialize sgt for dmabuf\n", PTR_ERR(sgt));
> +	mapping = alloc_sgt_from_device_pages(hdev, pages, npages, page_size,
> +					      exported_size, offset,
> +					      dma_buf_sgt_dma_device(attachment),
> +					      dir);
> +	if (IS_ERR(mapping))
> +		dev_err(hdev->dev, "failed (%ld) to initialize sgt for dmabuf\n", PTR_ERR(mapping));
>   
> -	return sgt;
> +	return mapping;
>   }
>   
>   static void hl_unmap_dmabuf(struct dma_buf_attachment *attachment,
> -				  struct sg_table *sgt,
> +				  struct dma_buf_sgt_mapping *mapping,
>   				  enum dma_data_direction dir)
>   {
> +	struct sg_table *sgt = &mapping->sgt;
>   	struct scatterlist *sg;
>   	int i;
>   
> @@ -1776,14 +1783,14 @@ static void hl_unmap_dmabuf(struct dma_buf_attachment *attachment,
>   	 * a sync of the memory to the CPU's cache, as it never resided inside that cache.
>   	 */
>   	for_each_sgtable_dma_sg(sgt, sg, i)
> -		dma_unmap_resource(attachment->dev, sg_dma_address(sg),
> -					sg_dma_len(sg), dir,
> -					DMA_ATTR_SKIP_CPU_SYNC);
> +		dma_unmap_resource(dma_buf_sgt_mapping_dma_device(mapping),
> +				   sg_dma_address(sg), sg_dma_len(sg), dir,
> +				   DMA_ATTR_SKIP_CPU_SYNC);
>   
>   	/* Need to restore orig_nents because sg_free_table use that field */
>   	sgt->orig_nents = sgt->nents;
>   	sg_free_table(sgt);
> -	kfree(sgt);
> +	kfree(mapping);
>   }
>   
>   static struct hl_vm_hash_node *memhash_node_export_get(struct hl_ctx *ctx, u64 addr)
> @@ -1850,9 +1857,8 @@ static void hl_release_dmabuf(struct dma_buf *dmabuf)
>   
>   static const struct dma_buf_ops habanalabs_dmabuf_ops = {
>   	.attach = hl_dmabuf_attach,
> -	.map_dma_buf = hl_map_dmabuf,
> -	.unmap_dma_buf = hl_unmap_dmabuf,
>   	.release = hl_release_dmabuf,
> +	DMA_BUF_SIMPLE_SGT_EXP_MATCH(hl_map_dmabuf, hl_unmap_dmabuf),
>   };
>   
>   static int export_dmabuf(struct hl_ctx *ctx,
> diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c
> index 044acdef6351..1eff00567386 100644
> --- a/drivers/gpu/drm/armada/armada_gem.c
> +++ b/drivers/gpu/drm/armada/armada_gem.c
> @@ -4,6 +4,7 @@
>    */
>   
>   #include <linux/dma-buf.h>
> +#include <linux/dma-buf-mapping.h>
>   #include <linux/dma-mapping.h>
>   #include <linux/mman.h>
>   #include <linux/shmem_fs.h>
> @@ -383,41 +384,44 @@ int armada_gem_pwrite_ioctl(struct drm_device *dev, void *data,
>   }
>   
>   /* Prime support */
> -static struct sg_table *
> +static struct dma_buf_sgt_mapping *
>   armada_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
>   	enum dma_data_direction dir)
>   {
> +	struct device *dma_dev = dma_buf_sgt_dma_device(attach);
>   	struct drm_gem_object *obj = attach->dmabuf->priv;
>   	struct armada_gem_object *dobj = drm_to_armada_gem(obj);
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct scatterlist *sg;
>   	struct sg_table *sgt;
>   	int i;
>   
> -	sgt = kmalloc_obj(*sgt);
> -	if (!sgt)
> +	mapping = kzalloc_obj(*mapping);
> +	if (!mapping)
>   		return NULL;
> +	sgt = &mapping->sgt;
>   
>   	if (dobj->obj.filp) {
> -		struct address_space *mapping;
> +		struct address_space *file_mapping;
>   		int count;
>   
>   		count = dobj->obj.size / PAGE_SIZE;
>   		if (sg_alloc_table(sgt, count, GFP_KERNEL))
>   			goto free_sgt;
>   
> -		mapping = dobj->obj.filp->f_mapping;
> +		file_mapping = dobj->obj.filp->f_mapping;
>   
>   		for_each_sgtable_sg(sgt, sg, i) {
>   			struct page *page;
>   
> -			page = shmem_read_mapping_page(mapping, i);
> +			page = shmem_read_mapping_page(file_mapping, i);
>   			if (IS_ERR(page))
>   				goto release;
>   
>   			sg_set_page(sg, page, PAGE_SIZE, 0);
>   		}
>   
> -		if (dma_map_sgtable(attach->dev, sgt, dir, 0))
> +		if (dma_map_sgtable(dma_dev, sgt, dir, 0))
>   			goto release;
>   	} else if (dobj->page) {
>   		/* Single contiguous page */
> @@ -426,7 +430,7 @@ armada_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
>   
>   		sg_set_page(sgt->sgl, dobj->page, dobj->obj.size, 0);
>   
> -		if (dma_map_sgtable(attach->dev, sgt, dir, 0))
> +		if (dma_map_sgtable(dma_dev, sgt, dir, 0))
>   			goto free_table;
>   	} else if (dobj->linear) {
>   		/* Single contiguous physical region - no struct page */
> @@ -437,7 +441,7 @@ armada_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
>   	} else {
>   		goto free_sgt;
>   	}
> -	return sgt;
> +	return mapping;
>   
>    release:
>   	for_each_sgtable_sg(sgt, sg, i)
> @@ -446,19 +450,21 @@ armada_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
>    free_table:
>   	sg_free_table(sgt);
>    free_sgt:
> -	kfree(sgt);
> +	kfree(mapping);
>   	return NULL;
>   }
>   
>   static void armada_gem_prime_unmap_dma_buf(struct dma_buf_attachment *attach,
> -	struct sg_table *sgt, enum dma_data_direction dir)
> +	struct dma_buf_sgt_mapping *mapping, enum dma_data_direction dir)
>   {
>   	struct drm_gem_object *obj = attach->dmabuf->priv;
>   	struct armada_gem_object *dobj = drm_to_armada_gem(obj);
> +	struct sg_table *sgt = &mapping->sgt;
>   	int i;
>   
>   	if (!dobj->linear)
> -		dma_unmap_sgtable(attach->dev, sgt, dir, 0);
> +		dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping), sgt,
> +				  dir, 0);
>   
>   	if (dobj->obj.filp) {
>   		struct scatterlist *sg;
> @@ -468,7 +474,7 @@ static void armada_gem_prime_unmap_dma_buf(struct dma_buf_attachment *attach,
>   	}
>   
>   	sg_free_table(sgt);
> -	kfree(sgt);
> +	kfree(mapping);
>   }
>   
>   static int
> @@ -478,10 +484,10 @@ armada_gem_dmabuf_mmap(struct dma_buf *buf, struct vm_area_struct *vma)
>   }
>   
>   static const struct dma_buf_ops armada_gem_prime_dmabuf_ops = {
> -	.map_dma_buf	= armada_gem_prime_map_dma_buf,
> -	.unmap_dma_buf	= armada_gem_prime_unmap_dma_buf,
>   	.release	= drm_gem_dmabuf_release,
>   	.mmap		= armada_gem_dmabuf_mmap,
> +	DMA_BUF_SIMPLE_SGT_EXP_MATCH(armada_gem_prime_map_dma_buf,
> +				     armada_gem_prime_unmap_dma_buf),
>   };
>   
>   struct dma_buf *
> diff --git a/drivers/gpu/drm/i915/gem/selftests/mock_dmabuf.c b/drivers/gpu/drm/i915/gem/selftests/mock_dmabuf.c
> index f2863da7f5c1..bba066f3cb50 100644
> --- a/drivers/gpu/drm/i915/gem/selftests/mock_dmabuf.c
> +++ b/drivers/gpu/drm/i915/gem/selftests/mock_dmabuf.c
> @@ -4,20 +4,24 @@
>    * Copyright © 2016 Intel Corporation
>    */
>   
> +#include <linux/dma-buf-mapping.h>
>   #include <linux/vmalloc.h>
>   #include "mock_dmabuf.h"
>   
> -static struct sg_table *mock_map_dma_buf(struct dma_buf_attachment *attachment,
> -					 enum dma_data_direction dir)
> +static struct dma_buf_sgt_mapping *
> +mock_map_dma_buf(struct dma_buf_attachment *attachment,
> +		 enum dma_data_direction dir)
>   {
>   	struct mock_dmabuf *mock = to_mock(attachment->dmabuf);
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct sg_table *st;
>   	struct scatterlist *sg;
>   	int i, err;
>   
> -	st = kmalloc_obj(*st);
> -	if (!st)
> +	mapping = kzalloc_obj(*mapping);
> +	if (!mapping)
>   		return ERR_PTR(-ENOMEM);
> +	st = &mapping->sgt;
>   
>   	err = sg_alloc_table(st, mock->npages, GFP_KERNEL);
>   	if (err)
> @@ -29,26 +33,27 @@ static struct sg_table *mock_map_dma_buf(struct dma_buf_attachment *attachment,
>   		sg = sg_next(sg);
>   	}
>   
> -	err = dma_map_sgtable(attachment->dev, st, dir, 0);
> +	err = dma_map_sgtable(dma_buf_sgt_dma_device(attachment), st, dir, 0);
>   	if (err)
>   		goto err_st;
>   
> -	return st;
> +	return mapping;
>   
>   err_st:
>   	sg_free_table(st);
>   err_free:
> -	kfree(st);
> +	kfree(mapping);
>   	return ERR_PTR(err);
>   }
>   
>   static void mock_unmap_dma_buf(struct dma_buf_attachment *attachment,
> -			       struct sg_table *st,
> +			       struct dma_buf_sgt_mapping *mapping,
>   			       enum dma_data_direction dir)
>   {
> -	dma_unmap_sgtable(attachment->dev, st, dir, 0);
> -	sg_free_table(st);
> -	kfree(st);
> +	dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping),
> +			  &mapping->sgt, dir, 0);
> +	sg_free_table(&mapping->sgt);
> +	kfree(mapping);
>   }
>   
>   static void mock_dmabuf_release(struct dma_buf *dma_buf)
> @@ -88,12 +93,11 @@ static int mock_dmabuf_mmap(struct dma_buf *dma_buf, struct vm_area_struct *vma)
>   }
>   
>   static const struct dma_buf_ops mock_dmabuf_ops =  {
> -	.map_dma_buf = mock_map_dma_buf,
> -	.unmap_dma_buf = mock_unmap_dma_buf,
>   	.release = mock_dmabuf_release,
>   	.mmap = mock_dmabuf_mmap,
>   	.vmap = mock_dmabuf_vmap,
>   	.vunmap = mock_dmabuf_vunmap,
> +	DMA_BUF_SIMPLE_SGT_EXP_MATCH(mock_map_dma_buf, mock_unmap_dma_buf),
>   };
>   
>   static struct dma_buf *mock_dmabuf(int npages)
> diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c
> index e6aa6dae4ec8..8e288a34f10f 100644
> --- a/drivers/gpu/drm/tegra/gem.c
> +++ b/drivers/gpu/drm/tegra/gem.c
> @@ -11,6 +11,7 @@
>    */
>   
>   #include <linux/dma-buf.h>
> +#include <linux/dma-buf-mapping.h>
>   #include <linux/iommu.h>
>   #include <linux/module.h>
>   #include <linux/pagemap.h>
> @@ -626,51 +627,56 @@ int tegra_drm_mmap(struct file *file, struct vm_area_struct *vma)
>   	return __tegra_gem_mmap(gem, vma);
>   }
>   
> -static struct sg_table *
> +static struct dma_buf_sgt_mapping *
>   tegra_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
>   			    enum dma_data_direction dir)
>   {
> +	struct device *dma_dev = dma_buf_sgt_dma_device(attach);
>   	struct drm_gem_object *gem = attach->dmabuf->priv;
>   	struct tegra_bo *bo = to_tegra_bo(gem);
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct sg_table *sgt;
>   
> -	sgt = kmalloc_obj(*sgt);
> -	if (!sgt)
> +	mapping = kzalloc_obj(*mapping);
> +	if (!mapping)
>   		return NULL;
> +	sgt = &mapping->sgt;
>   
>   	if (bo->pages) {
>   		if (sg_alloc_table_from_pages(sgt, bo->pages, bo->num_pages,
>   					      0, gem->size, GFP_KERNEL) < 0)
>   			goto free;
>   	} else {
> -		if (dma_get_sgtable(attach->dev, sgt, bo->vaddr, bo->iova,
> +		if (dma_get_sgtable(dma_dev, sgt, bo->vaddr, bo->iova,
>   				    gem->size) < 0)
>   			goto free;
>   	}
>   
> -	if (dma_map_sgtable(attach->dev, sgt, dir, 0))
> +	if (dma_map_sgtable(dma_dev, sgt, dir, 0))
>   		goto free;
>   
> -	return sgt;
> +	return mapping;
>   
>   free:
>   	sg_free_table(sgt);
> -	kfree(sgt);
> +	kfree(mapping);
>   	return NULL;
>   }
>   
>   static void tegra_gem_prime_unmap_dma_buf(struct dma_buf_attachment *attach,
> -					  struct sg_table *sgt,
> +					  struct dma_buf_sgt_mapping *mapping,
>   					  enum dma_data_direction dir)
>   {
>   	struct drm_gem_object *gem = attach->dmabuf->priv;
>   	struct tegra_bo *bo = to_tegra_bo(gem);
> +	struct sg_table *sgt = &mapping->sgt;
>   
>   	if (bo->pages)
> -		dma_unmap_sgtable(attach->dev, sgt, dir, 0);
> +		dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping), sgt,
> +				  dir, 0);
>   
>   	sg_free_table(sgt);
> -	kfree(sgt);
> +	kfree(mapping);
>   }
>   
>   static void tegra_gem_prime_release(struct dma_buf *buf)
> @@ -740,14 +746,14 @@ static void tegra_gem_prime_vunmap(struct dma_buf *buf, struct iosys_map *map)
>   }
>   
>   static const struct dma_buf_ops tegra_gem_prime_dmabuf_ops = {
> -	.map_dma_buf = tegra_gem_prime_map_dma_buf,
> -	.unmap_dma_buf = tegra_gem_prime_unmap_dma_buf,
>   	.release = tegra_gem_prime_release,
>   	.begin_cpu_access = tegra_gem_prime_begin_cpu_access,
>   	.end_cpu_access = tegra_gem_prime_end_cpu_access,
>   	.mmap = tegra_gem_prime_mmap,
>   	.vmap = tegra_gem_prime_vmap,
>   	.vunmap = tegra_gem_prime_vunmap,
> +	DMA_BUF_SIMPLE_SGT_EXP_MATCH(tegra_gem_prime_map_dma_buf,
> +				     tegra_gem_prime_unmap_dma_buf),
>   };
>   
>   struct dma_buf *tegra_gem_prime_export(struct drm_gem_object *gem,
> diff --git a/samples/vfio-mdev/mbochs.c b/samples/vfio-mdev/mbochs.c
> index 64ea19253ee3..3502d0b37bd1 100644
> --- a/samples/vfio-mdev/mbochs.c
> +++ b/samples/vfio-mdev/mbochs.c
> @@ -32,6 +32,7 @@
>   #include <linux/pci.h>
>   #include <linux/dma-buf.h>
>   #include <linux/highmem.h>
> +#include <linux/dma-buf-mapping.h>
>   #include <drm/drm_fourcc.h>
>   #include <drm/drm_rect.h>
>   #include <drm/drm_modeset_lock.h>
> @@ -857,46 +858,51 @@ static void mbochs_print_dmabuf(struct mbochs_dmabuf *dmabuf,
>   		dmabuf->mode.offset, dmabuf->mode.size, dmabuf->pagecount);
>   }
>   
> -static struct sg_table *mbochs_map_dmabuf(struct dma_buf_attachment *at,
> -					  enum dma_data_direction direction)
> +static struct dma_buf_sgt_mapping *
> +mbochs_map_dmabuf(struct dma_buf_attachment *at,
> +		  enum dma_data_direction direction)
>   {
>   	struct mbochs_dmabuf *dmabuf = at->dmabuf->priv;
>   	struct device *dev = mdev_dev(dmabuf->mdev_state->mdev);
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct sg_table *sg;
>   
>   	dev_dbg(dev, "%s: %d\n", __func__, dmabuf->id);
>   
> -	sg = kzalloc(sizeof(*sg), GFP_KERNEL);
> -	if (!sg)
> +	mapping = kzalloc_obj(*mapping);
> +	if (!mapping)
>   		goto err1;
> +	sg = &mapping->sgt;
>   	if (sg_alloc_table_from_pages(sg, dmabuf->pages, dmabuf->pagecount,
>   				      0, dmabuf->mode.size, GFP_KERNEL) < 0)
>   		goto err2;
> -	if (dma_map_sgtable(at->dev, sg, direction, 0))
> +	if (dma_map_sgtable(dma_buf_sgt_dma_device(at), sg, direction, 0))
>   		goto err3;
>   
> -	return sg;
> +	return mapping;
>   
>   err3:
>   	sg_free_table(sg);
>   err2:
> -	kfree(sg);
> +	kfree(mapping);
>   err1:
>   	return ERR_PTR(-ENOMEM);
>   }
>   
>   static void mbochs_unmap_dmabuf(struct dma_buf_attachment *at,
> -				struct sg_table *sg,
> +				struct dma_buf_sgt_mapping *mapping,
>   				enum dma_data_direction direction)
>   {
>   	struct mbochs_dmabuf *dmabuf = at->dmabuf->priv;
>   	struct device *dev = mdev_dev(dmabuf->mdev_state->mdev);
> +	struct sg_table *sg = &mapping->sgt;
>   
>   	dev_dbg(dev, "%s: %d\n", __func__, dmabuf->id);
>   
> -	dma_unmap_sgtable(at->dev, sg, direction, 0);
> +	dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping), sg,
> +			  direction, 0);
>   	sg_free_table(sg);
> -	kfree(sg);
> +	kfree(mapping);
>   }
>   
>   static void mbochs_release_dmabuf(struct dma_buf *buf)
> @@ -918,11 +924,10 @@ static void mbochs_release_dmabuf(struct dma_buf *buf)
>   	mutex_unlock(&mdev_state->ops_lock);
>   }
>   
> -static struct dma_buf_ops mbochs_dmabuf_ops = {
> -	.map_dma_buf	  = mbochs_map_dmabuf,
> -	.unmap_dma_buf	  = mbochs_unmap_dmabuf,
> +static const struct dma_buf_ops mbochs_dmabuf_ops = {
>   	.release	  = mbochs_release_dmabuf,
>   	.mmap		  = mbochs_mmap_dmabuf,
> +	DMA_BUF_SIMPLE_SGT_EXP_MATCH(mbochs_map_dmabuf, mbochs_unmap_dmabuf),
>   };
>   
>   static struct mbochs_dmabuf *mbochs_dmabuf_alloc(struct mdev_state *mdev_state,
> diff --git a/sound/soc/fsl/fsl_asrc_m2m.c b/sound/soc/fsl/fsl_asrc_m2m.c
> index 58101ce07c9f..79fde68f9394 100644
> --- a/sound/soc/fsl/fsl_asrc_m2m.c
> +++ b/sound/soc/fsl/fsl_asrc_m2m.c
> @@ -7,6 +7,7 @@
>   
>   #include <linux/dma/imx-dma.h>
>   #include <linux/dma-buf.h>
> +#include <linux/dma-buf-mapping.h>
>   #include <linux/dma-mapping.h>
>   #include <linux/pm_runtime.h>
>   #include <sound/asound.h>
> @@ -414,35 +415,42 @@ static int fsl_asrc_m2m_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
>   	return snd_dma_buffer_mmap(dmab, vma);
>   }
>   
> -static struct sg_table *fsl_asrc_m2m_map_dma_buf(struct dma_buf_attachment *attachment,
> -						 enum dma_data_direction direction)
> +static struct dma_buf_sgt_mapping *
> +fsl_asrc_m2m_map_dma_buf(struct dma_buf_attachment *attachment,
> +			 enum dma_data_direction direction)
>   {
> +	struct device *dma_dev = dma_buf_sgt_dma_device(attachment);
>   	struct snd_dma_buffer *dmab = attachment->dmabuf->priv;
> +	struct dma_buf_sgt_mapping *mapping;
>   	struct sg_table *sgt;
>   
> -	sgt = kmalloc_obj(*sgt);
> -	if (!sgt)
> +	mapping = kzalloc_obj(*mapping);
> +	if (!mapping)
>   		return NULL;
> +	sgt = &mapping->sgt;
>   
> -	if (dma_get_sgtable(attachment->dev, sgt, dmab->area, dmab->addr, dmab->bytes) < 0)
> +	if (dma_get_sgtable(dma_dev, sgt, dmab->area, dmab->addr, dmab->bytes) < 0)
>   		goto free;
>   
> -	if (dma_map_sgtable(attachment->dev, sgt, direction, 0))
> +	if (dma_map_sgtable(dma_dev, sgt, direction, 0))
>   		goto free;
>   
> -	return sgt;
> +	return mapping;
>   
>   free:
>   	sg_free_table(sgt);
> -	kfree(sgt);
> +	kfree(mapping);
>   	return NULL;
>   }
>   
>   static void fsl_asrc_m2m_unmap_dma_buf(struct dma_buf_attachment *attachment,
> -				       struct sg_table *table,
> +				       struct dma_buf_sgt_mapping *mapping,
>   				       enum dma_data_direction direction)
>   {
> -	dma_unmap_sgtable(attachment->dev, table, direction, 0);
> +	dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping),
> +			  &mapping->sgt, direction, 0);
> +	sg_free_table(&mapping->sgt);
> +	kfree(mapping);
>   }
>   
>   static void fsl_asrc_m2m_release(struct dma_buf *dmabuf)
> @@ -452,9 +460,9 @@ static void fsl_asrc_m2m_release(struct dma_buf *dmabuf)
>   
>   static const struct dma_buf_ops fsl_asrc_m2m_dma_buf_ops = {
>   	.mmap = fsl_asrc_m2m_mmap,
> -	.map_dma_buf = fsl_asrc_m2m_map_dma_buf,
> -	.unmap_dma_buf = fsl_asrc_m2m_unmap_dma_buf,
>   	.release = fsl_asrc_m2m_release,
> +	DMA_BUF_SIMPLE_SGT_EXP_MATCH(fsl_asrc_m2m_map_dma_buf,
> +				     fsl_asrc_m2m_unmap_dma_buf),
>   };
>   
>   static int fsl_asrc_m2m_comp_task_create(struct snd_compr_stream *stream,
> 

Acked-by: Karol Wachowski <karol.wachowski@linux.intel.com>

  reply	other threads:[~2026-11-20  9:02 UTC|newest]

Thread overview: 26+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20  5:55 [PATCH v3 00/24] DMA-buf mapping types Alistair Popple
2026-11-20  5:55 ` [PATCH v3 01/24] treewide: Rename dma_buf_(un)map_attachment() to dma_buf_(un)map_sgt() Alistair Popple
2026-11-20  5:55 ` [PATCH v3 02/24] dma-buf: Introduce DMA-buf mapping types Alistair Popple
2026-11-20  5:55 ` [PATCH v3 03/24] dma-buf: Add the SGT DMA mapping type Alistair Popple
2026-11-20  5:55 ` [PATCH v3 04/24] dma-buf: Negotiate the mapping type in dma_buf_dynamic_attach() Alistair Popple
2026-11-20  5:55 ` [PATCH v3 05/24] dma-buf: Route SGT related actions through the attachment's mapping type Alistair Popple
2026-11-20  5:55 ` [PATCH v3 06/24] dma-buf: Allow single exporter drivers to avoid the match_mapping function Alistair Popple
2026-11-20  5:55 ` [PATCH v3 07/24] dma-buf: Convert exporters allocating a table per map to the SGT mapping type Alistair Popple
2026-11-20  9:02   ` Karol Wachowski [this message]
2026-11-20  5:55 ` [PATCH v3 08/24] iommufd/selftest: Convert the test exporter " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 09/24] dma-buf: Convert exporters keeping a table per attachment " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 10/24] drm: Convert drm_gem_map_dma_buf() and its users " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 11/24] drm/xe/dma-buf: Use " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 12/24] drm/amdgpu: " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 13/24] udmabuf: Convert to " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 14/24] drm/omapdrm: " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 15/24] accel/ivpu: Convert the userptr exporter " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 16/24] drm/vmwgfx: Use match_mapping instead of dummy calls Alistair Popple
2026-11-20  5:55 ` [PATCH v3 17/24] dma-buf: Convert dma_buf_phys_vec_to_sgt() and its users to the SGT mapping type Alistair Popple
2026-11-20  5:55 ` [PATCH v3 18/24] iio: buffer: convert to use " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 19/24] functionfs: " Alistair Popple
2026-11-20  5:55 ` [PATCH v3 20/24] dma-buf: Remove unused SGT stuff from the common structures Alistair Popple
2026-11-20  5:55 ` [PATCH v3 21/24] dma-buf: Add kunit tests for mapping type Alistair Popple
2026-11-20  5:56 ` [PATCH v3 22/24] dma-buf: Let the exporter select mapping type at pin/map Alistair Popple
2026-11-20  5:56 ` [PATCH v3 23/24] dma-buf: Add dma_buf_mapping_map() returning a type-tagged mapping and implement it for sgt Alistair Popple
2026-11-20  5:56 ` [PATCH v3 24/24] dma-buf: Add kunit tests for mapping type selection Alistair Popple

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=47f2ff46-1837-43f5-a413-0dbf29716d7a@linux.intel.com \
    --to=karol.wachowski@linux.intel.com \
    --cc=aik@amd.com \
    --cc=alexander.deucher@amd.com \
    --cc=almasrymina@google.com \
    --cc=amd-gfx@lists.freedesktop.org \
    --cc=apopple@nvidia.com \
    --cc=axboe@kernel.dk \
    --cc=baolu.lu@linux.intel.com \
    --cc=chaitanyak@nvidia.com \
    --cc=christian.koenig@amd.com \
    --cc=davem@davemloft.net \
    --cc=dongwon.kim@intel.com \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=edumazet@kernel.org \
    --cc=felix.kuehling@amd.com \
    --cc=hch@lst.de \
    --cc=horms@kernel.org \
    --cc=intel-xe@lists.freedesktop.org \
    --cc=iommu@lists.linux.dev \
    --cc=jgg@ziepe.ca \
    --cc=jhubbard@nvidia.com \
    --cc=kbusch@kernel.org \
    --cc=kevin.tian@intel.com \
    --cc=kmehltretter@gmail.com \
    --cc=kuba@kernel.org \
    --cc=leon@kernel.org \
    --cc=linaro-mm-sig@lists.linaro.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-media@vger.kernel.org \
    --cc=linux-nvme@lists.infradead.org \
    --cc=linux-rdma@vger.kernel.org \
    --cc=matthew.brost@intel.com \
    --cc=netdev@vger.kernel.org \
    --cc=pabeni@redhat.com \
    --cc=sagi@grimberg.me \
    --cc=simona.vetter@ffwll.ch \
    --cc=sumit.semwal@linaro.org \
    --cc=thomas.hellstrom@linux.intel.com \
    --cc=treding@nvidia.com \
    --cc=vivek.kasireddy@intel.com \
    --cc=yilun.xu@linux.intel.com \
    --cc=zhipingz@meta.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.