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>
next prev parent 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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).