From: Alistair Popple <apopple@nvidia.com>
To: "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>
Cc: Alistair Popple <apopple@nvidia.com>
Subject: [PATCH v3 09/24] dma-buf: Convert exporters keeping a table per attachment to the SGT mapping type
Date: Fri, 20 Nov 2026 16:55:47 +1100 [thread overview]
Message-ID: <20261120-dma_mapping_type_v4-v3-9-c0183a409bdf@nvidia.com> (raw)
In-Reply-To: <20261120-dma_mapping_type_v4-v3-0-c0183a409bdf@nvidia.com>
These exporters all keep one struct sg_table per attachment. It is
embedded in either attachment private data or allocated and cached
on first map. The same table is returned on every map_dma_buf()
and nothing is freed in unmap_dma_buf(). Instead the table is freed
during detach.
The private/cached struct sg_table becomes a struct dma_buf_sgt_mapping and
map_dma_buf() returns it every time. That is safe because the
core only fills in the mapping's header, and fills it identically for
every attachment map.
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/dma-buf/heaps/cma_heap.c | 33 ++++++-----
drivers/dma-buf/heaps/system_heap.c | 34 ++++++-----
.../media/common/videobuf2/videobuf2-dma-contig.c | 34 +++++------
drivers/media/common/videobuf2/videobuf2-dma-sg.c | 33 ++++++-----
drivers/media/common/videobuf2/videobuf2-vmalloc.c | 32 ++++++-----
drivers/misc/fastrpc.c | 30 +++++-----
drivers/tee/tee_heap.c | 28 ++++-----
drivers/xen/gntdev-dmabuf.c | 67 ++++++++++++----------
8 files changed, 158 insertions(+), 133 deletions(-)
diff --git a/drivers/dma-buf/heaps/cma_heap.c b/drivers/dma-buf/heaps/cma_heap.c
index 3fb4b946c91a..79bbb31e31cf 100644
--- a/drivers/dma-buf/heaps/cma_heap.c
+++ b/drivers/dma-buf/heaps/cma_heap.c
@@ -14,6 +14,7 @@
#include <linux/cma.h>
#include <linux/dma-buf.h>
+#include <linux/dma-buf-mapping.h>
#include <linux/dma-heap.h>
#include <linux/dma-map-ops.h>
#include <linux/err.h>
@@ -48,7 +49,7 @@ struct cma_heap_buffer {
struct dma_heap_attachment {
struct device *dev;
- struct sg_table table;
+ struct dma_buf_sgt_mapping mapping;
struct list_head list;
bool mapped;
};
@@ -64,7 +65,7 @@ static int cma_heap_attach(struct dma_buf *dmabuf,
if (!a)
return -ENOMEM;
- ret = sg_alloc_table_from_pages(&a->table, buffer->pages,
+ ret = sg_alloc_table_from_pages(&a->mapping.sgt, buffer->pages,
buffer->pagecount, 0,
buffer->pagecount << PAGE_SHIFT,
GFP_KERNEL);
@@ -73,7 +74,7 @@ static int cma_heap_attach(struct dma_buf *dmabuf,
return ret;
}
- a->dev = attachment->dev;
+ a->dev = dma_buf_sgt_dma_device(attachment);
INIT_LIST_HEAD(&a->list);
a->mapped = false;
@@ -96,32 +97,35 @@ static void cma_heap_detach(struct dma_buf *dmabuf,
list_del(&a->list);
mutex_unlock(&buffer->lock);
- sg_free_table(&a->table);
+ sg_free_table(&a->mapping.sgt);
kfree(a);
}
-static struct sg_table *cma_heap_map_dma_buf(struct dma_buf_attachment *attachment,
- enum dma_data_direction direction)
+static struct dma_buf_sgt_mapping *
+cma_heap_map_dma_buf(struct dma_buf_attachment *attachment,
+ enum dma_data_direction direction)
{
struct dma_heap_attachment *a = attachment->priv;
- struct sg_table *table = &a->table;
+ struct sg_table *table = &a->mapping.sgt;
int ret;
- ret = dma_map_sgtable(attachment->dev, table, direction, 0);
+ ret = dma_map_sgtable(dma_buf_sgt_dma_device(attachment), table,
+ direction, 0);
if (ret)
return ERR_PTR(-ENOMEM);
a->mapped = true;
- return table;
+ return &a->mapping;
}
static void cma_heap_unmap_dma_buf(struct dma_buf_attachment *attachment,
- struct sg_table *table,
+ struct dma_buf_sgt_mapping *mapping,
enum dma_data_direction direction)
{
struct dma_heap_attachment *a = attachment->priv;
a->mapped = false;
- dma_unmap_sgtable(attachment->dev, table, direction, 0);
+ dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping),
+ &mapping->sgt, direction, 0);
}
static int cma_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
@@ -138,7 +142,7 @@ static int cma_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
list_for_each_entry(a, &buffer->attachments, list) {
if (!a->mapped)
continue;
- dma_sync_sgtable_for_cpu(a->dev, &a->table, direction);
+ dma_sync_sgtable_for_cpu(a->dev, &a->mapping.sgt, direction);
}
mutex_unlock(&buffer->lock);
@@ -159,7 +163,7 @@ static int cma_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf,
list_for_each_entry(a, &buffer->attachments, list) {
if (!a->mapped)
continue;
- dma_sync_sgtable_for_device(a->dev, &a->table, direction);
+ dma_sync_sgtable_for_device(a->dev, &a->mapping.sgt, direction);
}
mutex_unlock(&buffer->lock);
@@ -268,14 +272,13 @@ static void cma_heap_dma_buf_release(struct dma_buf *dmabuf)
static const struct dma_buf_ops cma_heap_buf_ops = {
.attach = cma_heap_attach,
.detach = cma_heap_detach,
- .map_dma_buf = cma_heap_map_dma_buf,
- .unmap_dma_buf = cma_heap_unmap_dma_buf,
.begin_cpu_access = cma_heap_dma_buf_begin_cpu_access,
.end_cpu_access = cma_heap_dma_buf_end_cpu_access,
.mmap = cma_heap_mmap,
.vmap = cma_heap_vmap,
.vunmap = cma_heap_vunmap,
.release = cma_heap_dma_buf_release,
+ DMA_BUF_SIMPLE_SGT_EXP_MATCH(cma_heap_map_dma_buf, cma_heap_unmap_dma_buf),
};
static struct dma_buf *cma_heap_allocate(struct dma_heap *heap,
diff --git a/drivers/dma-buf/heaps/system_heap.c b/drivers/dma-buf/heaps/system_heap.c
index c8959eadc71d..4c306f7fe506 100644
--- a/drivers/dma-buf/heaps/system_heap.c
+++ b/drivers/dma-buf/heaps/system_heap.c
@@ -12,6 +12,7 @@
#include <linux/cc_platform.h>
#include <linux/dma-buf.h>
+#include <linux/dma-buf-mapping.h>
#include <linux/dma-mapping.h>
#include <linux/dma-heap.h>
#include <linux/err.h>
@@ -42,7 +43,7 @@ struct system_heap_buffer {
struct dma_heap_attachment {
struct device *dev;
- struct sg_table table;
+ struct dma_buf_sgt_mapping mapping;
struct list_head list;
bool mapped;
bool cc_shared;
@@ -122,13 +123,13 @@ static int system_heap_attach(struct dma_buf *dmabuf,
if (!a)
return -ENOMEM;
- ret = dup_sg_table(&buffer->sg_table, &a->table);
+ ret = dup_sg_table(&buffer->sg_table, &a->mapping.sgt);
if (ret) {
kfree(a);
return ret;
}
- a->dev = attachment->dev;
+ a->dev = dma_buf_sgt_dma_device(attachment);
INIT_LIST_HEAD(&a->list);
a->mapped = false;
a->cc_shared = buffer->cc_shared;
@@ -152,35 +153,38 @@ static void system_heap_detach(struct dma_buf *dmabuf,
list_del(&a->list);
mutex_unlock(&buffer->lock);
- sg_free_table(&a->table);
+ sg_free_table(&a->mapping.sgt);
kfree(a);
}
-static struct sg_table *system_heap_map_dma_buf(struct dma_buf_attachment *attachment,
- enum dma_data_direction direction)
+static struct dma_buf_sgt_mapping *
+system_heap_map_dma_buf(struct dma_buf_attachment *attachment,
+ enum dma_data_direction direction)
{
struct dma_heap_attachment *a = attachment->priv;
- struct sg_table *table = &a->table;
+ struct sg_table *table = &a->mapping.sgt;
unsigned long attrs;
int ret;
attrs = cc_shared_buffer(a) ? DMA_ATTR_CC_SHARED : 0;
- ret = dma_map_sgtable(attachment->dev, table, direction, attrs);
+ ret = dma_map_sgtable(dma_buf_sgt_dma_device(attachment), table,
+ direction, attrs);
if (ret)
return ERR_PTR(ret);
a->mapped = true;
- return table;
+ return &a->mapping;
}
static void system_heap_unmap_dma_buf(struct dma_buf_attachment *attachment,
- struct sg_table *table,
+ struct dma_buf_sgt_mapping *mapping,
enum dma_data_direction direction)
{
struct dma_heap_attachment *a = attachment->priv;
a->mapped = false;
- dma_unmap_sgtable(attachment->dev, table, direction, 0);
+ dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping),
+ &mapping->sgt, direction, 0);
}
static int system_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
@@ -197,7 +201,7 @@ static int system_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
list_for_each_entry(a, &buffer->attachments, list) {
if (!a->mapped)
continue;
- dma_sync_sgtable_for_cpu(a->dev, &a->table, direction);
+ dma_sync_sgtable_for_cpu(a->dev, &a->mapping.sgt, direction);
}
mutex_unlock(&buffer->lock);
@@ -218,7 +222,7 @@ static int system_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf,
list_for_each_entry(a, &buffer->attachments, list) {
if (!a->mapped)
continue;
- dma_sync_sgtable_for_device(a->dev, &a->table, direction);
+ dma_sync_sgtable_for_device(a->dev, &a->mapping.sgt, direction);
}
mutex_unlock(&buffer->lock);
@@ -365,14 +369,14 @@ static void system_heap_dma_buf_release(struct dma_buf *dmabuf)
static const struct dma_buf_ops system_heap_buf_ops = {
.attach = system_heap_attach,
.detach = system_heap_detach,
- .map_dma_buf = system_heap_map_dma_buf,
- .unmap_dma_buf = system_heap_unmap_dma_buf,
.begin_cpu_access = system_heap_dma_buf_begin_cpu_access,
.end_cpu_access = system_heap_dma_buf_end_cpu_access,
.mmap = system_heap_mmap,
.vmap = system_heap_vmap,
.vunmap = system_heap_vunmap,
.release = system_heap_dma_buf_release,
+ DMA_BUF_SIMPLE_SGT_EXP_MATCH(system_heap_map_dma_buf,
+ system_heap_unmap_dma_buf),
};
static struct page *alloc_largest_available(unsigned long size,
diff --git a/drivers/media/common/videobuf2/videobuf2-dma-contig.c b/drivers/media/common/videobuf2/videobuf2-dma-contig.c
index 284482335c1a..5f410c6c653d 100644
--- a/drivers/media/common/videobuf2/videobuf2-dma-contig.c
+++ b/drivers/media/common/videobuf2/videobuf2-dma-contig.c
@@ -11,6 +11,7 @@
*/
#include <linux/dma-buf.h>
+#include <linux/dma-buf-mapping.h>
#include <linux/module.h>
#include <linux/refcount.h>
#include <linux/scatterlist.h>
@@ -311,7 +312,7 @@ static int vb2_dc_mmap(void *buf_priv, struct vm_area_struct *vma)
/*********************************************/
struct vb2_dc_attachment {
- struct sg_table sgt;
+ struct dma_buf_sgt_mapping mapping;
enum dma_data_direction dma_dir;
};
@@ -329,7 +330,7 @@ static int vb2_dc_dmabuf_ops_attach(struct dma_buf *dbuf,
if (!attach)
return -ENOMEM;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
/* Copy the buf->base_sgt scatter list to the attachment, as we can't
* map the same scatter list to multiple attachments at the same time.
*/
@@ -362,7 +363,7 @@ static void vb2_dc_dmabuf_ops_detach(struct dma_buf *dbuf,
if (!attach)
return;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
/* release the scatterlist cache */
if (attach->dma_dir != DMA_NONE)
@@ -372,28 +373,29 @@ static void vb2_dc_dmabuf_ops_detach(struct dma_buf *dbuf,
* memory locations do not require any explicit cache
* maintenance prior or after being used by the device.
*/
- dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir,
- DMA_ATTR_SKIP_CPU_SYNC);
+ dma_unmap_sgtable(dma_buf_sgt_dma_device(db_attach), sgt,
+ attach->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
sg_free_table(sgt);
kfree(attach);
db_attach->priv = NULL;
}
-static struct sg_table *vb2_dc_dmabuf_ops_map(
- struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
+static struct dma_buf_sgt_mapping *
+vb2_dc_dmabuf_ops_map(struct dma_buf_attachment *db_attach,
+ enum dma_data_direction dma_dir)
{
struct vb2_dc_attachment *attach = db_attach->priv;
struct sg_table *sgt;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
/* return previously mapped sg table */
if (attach->dma_dir == dma_dir)
- return sgt;
+ return &attach->mapping;
/* release any previous cache */
if (attach->dma_dir != DMA_NONE) {
- dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir,
- DMA_ATTR_SKIP_CPU_SYNC);
+ dma_unmap_sgtable(dma_buf_sgt_dma_device(db_attach), sgt,
+ attach->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
attach->dma_dir = DMA_NONE;
}
@@ -401,7 +403,7 @@ static struct sg_table *vb2_dc_dmabuf_ops_map(
* mapping to the client with new direction, no cache sync
* required see comment in vb2_dc_dmabuf_ops_detach()
*/
- if (dma_map_sgtable(db_attach->dev, sgt, dma_dir,
+ if (dma_map_sgtable(dma_buf_sgt_dma_device(db_attach), sgt, dma_dir,
DMA_ATTR_SKIP_CPU_SYNC)) {
pr_err("failed to map scatterlist\n");
return ERR_PTR(-EIO);
@@ -409,11 +411,11 @@ static struct sg_table *vb2_dc_dmabuf_ops_map(
attach->dma_dir = dma_dir;
- return sgt;
+ return &attach->mapping;
}
static void vb2_dc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
- struct sg_table *sgt, enum dma_data_direction dma_dir)
+ struct dma_buf_sgt_mapping *mapping, enum dma_data_direction dma_dir)
{
/* nothing to be done here */
}
@@ -462,13 +464,13 @@ static int vb2_dc_dmabuf_ops_mmap(struct dma_buf *dbuf,
static const struct dma_buf_ops vb2_dc_dmabuf_ops = {
.attach = vb2_dc_dmabuf_ops_attach,
.detach = vb2_dc_dmabuf_ops_detach,
- .map_dma_buf = vb2_dc_dmabuf_ops_map,
- .unmap_dma_buf = vb2_dc_dmabuf_ops_unmap,
.begin_cpu_access = vb2_dc_dmabuf_ops_begin_cpu_access,
.end_cpu_access = vb2_dc_dmabuf_ops_end_cpu_access,
.vmap = vb2_dc_dmabuf_ops_vmap,
.mmap = vb2_dc_dmabuf_ops_mmap,
.release = vb2_dc_dmabuf_ops_release,
+ DMA_BUF_SIMPLE_SGT_EXP_MATCH(vb2_dc_dmabuf_ops_map,
+ vb2_dc_dmabuf_ops_unmap),
};
static struct sg_table *vb2_dc_get_base_sgt(struct vb2_dc_buf *buf)
diff --git a/drivers/media/common/videobuf2/videobuf2-dma-sg.c b/drivers/media/common/videobuf2/videobuf2-dma-sg.c
index 54b07e3840ac..c00863ac0f88 100644
--- a/drivers/media/common/videobuf2/videobuf2-dma-sg.c
+++ b/drivers/media/common/videobuf2/videobuf2-dma-sg.c
@@ -10,6 +10,7 @@
* the Free Software Foundation.
*/
+#include <linux/dma-buf-mapping.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/refcount.h>
@@ -362,7 +363,7 @@ static int vb2_dma_sg_mmap(void *buf_priv, struct vm_area_struct *vma)
/*********************************************/
struct vb2_dma_sg_attachment {
- struct sg_table sgt;
+ struct dma_buf_sgt_mapping mapping;
enum dma_data_direction dma_dir;
};
@@ -380,7 +381,7 @@ static int vb2_dma_sg_dmabuf_ops_attach(struct dma_buf *dbuf,
if (!attach)
return -ENOMEM;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
/* Copy the buf->base_sgt scatter list to the attachment, as we can't
* map the same scatter list to multiple attachments at the same time.
*/
@@ -413,46 +414,50 @@ static void vb2_dma_sg_dmabuf_ops_detach(struct dma_buf *dbuf,
if (!attach)
return;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
/* release the scatterlist cache */
if (attach->dma_dir != DMA_NONE)
- dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir, 0);
+ dma_unmap_sgtable(dma_buf_sgt_dma_device(db_attach), sgt,
+ attach->dma_dir, 0);
sg_free_table(sgt);
kfree(attach);
db_attach->priv = NULL;
}
-static struct sg_table *vb2_dma_sg_dmabuf_ops_map(
- struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
+static struct dma_buf_sgt_mapping *
+vb2_dma_sg_dmabuf_ops_map(struct dma_buf_attachment *db_attach,
+ enum dma_data_direction dma_dir)
{
struct vb2_dma_sg_attachment *attach = db_attach->priv;
struct sg_table *sgt;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
/* return previously mapped sg table */
if (attach->dma_dir == dma_dir)
- return sgt;
+ return &attach->mapping;
/* release any previous cache */
if (attach->dma_dir != DMA_NONE) {
- dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir, 0);
+ dma_unmap_sgtable(dma_buf_sgt_dma_device(db_attach), sgt,
+ attach->dma_dir, 0);
attach->dma_dir = DMA_NONE;
}
/* mapping to the client with new direction */
- if (dma_map_sgtable(db_attach->dev, sgt, dma_dir, 0)) {
+ if (dma_map_sgtable(dma_buf_sgt_dma_device(db_attach), sgt, dma_dir,
+ 0)) {
pr_err("failed to map scatterlist\n");
return ERR_PTR(-EIO);
}
attach->dma_dir = dma_dir;
- return sgt;
+ return &attach->mapping;
}
static void vb2_dma_sg_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
- struct sg_table *sgt, enum dma_data_direction dma_dir)
+ struct dma_buf_sgt_mapping *mapping, enum dma_data_direction dma_dir)
{
/* nothing to be done here */
}
@@ -510,13 +515,13 @@ static int vb2_dma_sg_dmabuf_ops_mmap(struct dma_buf *dbuf,
static const struct dma_buf_ops vb2_dma_sg_dmabuf_ops = {
.attach = vb2_dma_sg_dmabuf_ops_attach,
.detach = vb2_dma_sg_dmabuf_ops_detach,
- .map_dma_buf = vb2_dma_sg_dmabuf_ops_map,
- .unmap_dma_buf = vb2_dma_sg_dmabuf_ops_unmap,
.begin_cpu_access = vb2_dma_sg_dmabuf_ops_begin_cpu_access,
.end_cpu_access = vb2_dma_sg_dmabuf_ops_end_cpu_access,
.vmap = vb2_dma_sg_dmabuf_ops_vmap,
.mmap = vb2_dma_sg_dmabuf_ops_mmap,
.release = vb2_dma_sg_dmabuf_ops_release,
+ DMA_BUF_SIMPLE_SGT_EXP_MATCH(vb2_dma_sg_dmabuf_ops_map,
+ vb2_dma_sg_dmabuf_ops_unmap),
};
static struct dma_buf *vb2_dma_sg_get_dmabuf(struct vb2_buffer *vb,
diff --git a/drivers/media/common/videobuf2/videobuf2-vmalloc.c b/drivers/media/common/videobuf2/videobuf2-vmalloc.c
index 63f023696f3e..0c4d14fe62da 100644
--- a/drivers/media/common/videobuf2/videobuf2-vmalloc.c
+++ b/drivers/media/common/videobuf2/videobuf2-vmalloc.c
@@ -10,6 +10,7 @@
* the Free Software Foundation.
*/
+#include <linux/dma-buf-mapping.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/mm.h>
@@ -205,7 +206,7 @@ static int vb2_vmalloc_mmap(void *buf_priv, struct vm_area_struct *vma)
/*********************************************/
struct vb2_vmalloc_attachment {
- struct sg_table sgt;
+ struct dma_buf_sgt_mapping mapping;
enum dma_data_direction dma_dir;
};
@@ -225,7 +226,7 @@ static int vb2_vmalloc_dmabuf_ops_attach(struct dma_buf *dbuf,
if (!attach)
return -ENOMEM;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
ret = sg_alloc_table(sgt, num_pages, GFP_KERNEL);
if (ret) {
kfree(attach);
@@ -257,46 +258,49 @@ static void vb2_vmalloc_dmabuf_ops_detach(struct dma_buf *dbuf,
if (!attach)
return;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
/* release the scatterlist cache */
if (attach->dma_dir != DMA_NONE)
- dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir, 0);
+ dma_unmap_sgtable(dma_buf_sgt_dma_device(db_attach), sgt,
+ attach->dma_dir, 0);
sg_free_table(sgt);
kfree(attach);
db_attach->priv = NULL;
}
-static struct sg_table *vb2_vmalloc_dmabuf_ops_map(
- struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
+static struct dma_buf_sgt_mapping *
+vb2_vmalloc_dmabuf_ops_map(struct dma_buf_attachment *db_attach,
+ enum dma_data_direction dma_dir)
{
+ struct device *dma_dev = dma_buf_sgt_dma_device(db_attach);
struct vb2_vmalloc_attachment *attach = db_attach->priv;
struct sg_table *sgt;
- sgt = &attach->sgt;
+ sgt = &attach->mapping.sgt;
/* return previously mapped sg table */
if (attach->dma_dir == dma_dir)
- return sgt;
+ return &attach->mapping;
/* release any previous cache */
if (attach->dma_dir != DMA_NONE) {
- dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir, 0);
+ dma_unmap_sgtable(dma_dev, sgt, attach->dma_dir, 0);
attach->dma_dir = DMA_NONE;
}
/* mapping to the client with new direction */
- if (dma_map_sgtable(db_attach->dev, sgt, dma_dir, 0)) {
+ if (dma_map_sgtable(dma_dev, sgt, dma_dir, 0)) {
pr_err("failed to map scatterlist\n");
return ERR_PTR(-EIO);
}
attach->dma_dir = dma_dir;
- return sgt;
+ return &attach->mapping;
}
static void vb2_vmalloc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
- struct sg_table *sgt, enum dma_data_direction dma_dir)
+ struct dma_buf_sgt_mapping *mapping, enum dma_data_direction dma_dir)
{
/* nothing to be done here */
}
@@ -326,11 +330,11 @@ static int vb2_vmalloc_dmabuf_ops_mmap(struct dma_buf *dbuf,
static const struct dma_buf_ops vb2_vmalloc_dmabuf_ops = {
.attach = vb2_vmalloc_dmabuf_ops_attach,
.detach = vb2_vmalloc_dmabuf_ops_detach,
- .map_dma_buf = vb2_vmalloc_dmabuf_ops_map,
- .unmap_dma_buf = vb2_vmalloc_dmabuf_ops_unmap,
.vmap = vb2_vmalloc_dmabuf_ops_vmap,
.mmap = vb2_vmalloc_dmabuf_ops_mmap,
.release = vb2_vmalloc_dmabuf_ops_release,
+ DMA_BUF_SIMPLE_SGT_EXP_MATCH(vb2_vmalloc_dmabuf_ops_map,
+ vb2_vmalloc_dmabuf_ops_unmap),
};
static struct dma_buf *vb2_vmalloc_get_dmabuf(struct vb2_buffer *vb,
diff --git a/drivers/misc/fastrpc.c b/drivers/misc/fastrpc.c
index 76c8dc05fa10..cbad55a93312 100644
--- a/drivers/misc/fastrpc.c
+++ b/drivers/misc/fastrpc.c
@@ -5,6 +5,7 @@
#include <linux/completion.h>
#include <linux/device.h>
#include <linux/dma-buf.h>
+#include <linux/dma-buf-mapping.h>
#include <linux/dma-mapping.h>
#include <linux/dma-resv.h>
#include <linux/idr.h>
@@ -234,7 +235,7 @@ struct fastrpc_buf {
struct fastrpc_dma_buf_attachment {
struct device *dev;
- struct sg_table sgt;
+ struct dma_buf_sgt_mapping mapping;
struct list_head node;
};
@@ -770,27 +771,26 @@ static struct fastrpc_invoke_ctx *fastrpc_context_alloc(
return ERR_PTR(ret);
}
-static struct sg_table *
+static struct dma_buf_sgt_mapping *
fastrpc_map_dma_buf(struct dma_buf_attachment *attachment,
enum dma_data_direction dir)
{
struct fastrpc_dma_buf_attachment *a = attachment->priv;
- struct sg_table *table;
int ret;
- table = &a->sgt;
-
- ret = dma_map_sgtable(attachment->dev, table, dir, 0);
+ ret = dma_map_sgtable(dma_buf_sgt_dma_device(attachment),
+ &a->mapping.sgt, dir, 0);
if (ret)
- table = ERR_PTR(ret);
- return table;
+ return ERR_PTR(ret);
+ return &a->mapping;
}
static void fastrpc_unmap_dma_buf(struct dma_buf_attachment *attach,
- struct sg_table *table,
+ struct dma_buf_sgt_mapping *mapping,
enum dma_data_direction dir)
{
- dma_unmap_sgtable(attach->dev, table, dir, 0);
+ dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping),
+ &mapping->sgt, dir, 0);
}
static void fastrpc_release(struct dma_buf *dmabuf)
@@ -811,7 +811,7 @@ static int fastrpc_dma_buf_attach(struct dma_buf *dmabuf,
if (!a)
return -ENOMEM;
- ret = dma_get_sgtable(buffer->dev, &a->sgt, buffer->virt,
+ ret = dma_get_sgtable(buffer->dev, &a->mapping.sgt, buffer->virt,
fastrpc_ipa_to_dma_addr(buffer->fl->cctx, buffer->dma_addr),
buffer->size);
if (ret < 0) {
@@ -820,7 +820,7 @@ static int fastrpc_dma_buf_attach(struct dma_buf *dmabuf,
return -EINVAL;
}
- a->dev = attachment->dev;
+ a->dev = dma_buf_sgt_dma_device(attachment);
INIT_LIST_HEAD(&a->node);
attachment->priv = a;
@@ -840,7 +840,7 @@ static void fastrpc_dma_buf_detatch(struct dma_buf *dmabuf,
mutex_lock(&buffer->lock);
list_del(&a->node);
mutex_unlock(&buffer->lock);
- sg_free_table(&a->sgt);
+ sg_free_table(&a->mapping.sgt);
kfree(a);
}
@@ -868,11 +868,11 @@ static int fastrpc_mmap(struct dma_buf *dmabuf,
static const struct dma_buf_ops fastrpc_dma_buf_ops = {
.attach = fastrpc_dma_buf_attach,
.detach = fastrpc_dma_buf_detatch,
- .map_dma_buf = fastrpc_map_dma_buf,
- .unmap_dma_buf = fastrpc_unmap_dma_buf,
.mmap = fastrpc_mmap,
.vmap = fastrpc_vmap,
.release = fastrpc_release,
+ DMA_BUF_SIMPLE_SGT_EXP_MATCH(fastrpc_map_dma_buf,
+ fastrpc_unmap_dma_buf),
};
static dma_addr_t fastrpc_compute_dma_addr(struct fastrpc_user *fl, dma_addr_t sg_dma_addr)
diff --git a/drivers/tee/tee_heap.c b/drivers/tee/tee_heap.c
index 007c00156520..1d8a941891e9 100644
--- a/drivers/tee/tee_heap.c
+++ b/drivers/tee/tee_heap.c
@@ -4,6 +4,7 @@
*/
#include <linux/dma-buf.h>
+#include <linux/dma-buf-mapping.h>
#include <linux/dma-heap.h>
#include <linux/genalloc.h>
#include <linux/module.h>
@@ -33,7 +34,7 @@ struct tee_heap_buffer {
};
struct tee_heap_attachment {
- struct sg_table table;
+ struct dma_buf_sgt_mapping mapping;
struct device *dev;
};
@@ -98,13 +99,13 @@ static int tee_heap_attach(struct dma_buf *dmabuf,
if (!a)
return -ENOMEM;
- ret = copy_sg_table(&a->table, &buf->table);
+ ret = copy_sg_table(&a->mapping.sgt, &buf->table);
if (ret) {
kfree(a);
return ret;
}
- a->dev = attachment->dev;
+ a->dev = dma_buf_sgt_dma_device(attachment);
attachment->priv = a;
return 0;
@@ -115,35 +116,36 @@ static void tee_heap_detach(struct dma_buf *dmabuf,
{
struct tee_heap_attachment *a = attachment->priv;
- sg_free_table(&a->table);
+ sg_free_table(&a->mapping.sgt);
kfree(a);
}
-static struct sg_table *
+static struct dma_buf_sgt_mapping *
tee_heap_map_dma_buf(struct dma_buf_attachment *attachment,
enum dma_data_direction direction)
{
struct tee_heap_attachment *a = attachment->priv;
int ret;
- ret = dma_map_sgtable(attachment->dev, &a->table, direction,
+ ret = dma_map_sgtable(dma_buf_sgt_dma_device(attachment),
+ &a->mapping.sgt, direction,
DMA_ATTR_SKIP_CPU_SYNC);
if (ret)
return ERR_PTR(ret);
- return &a->table;
+ return &a->mapping;
}
static void tee_heap_unmap_dma_buf(struct dma_buf_attachment *attachment,
- struct sg_table *table,
+ struct dma_buf_sgt_mapping *mapping,
enum dma_data_direction direction)
{
struct tee_heap_attachment *a = attachment->priv;
- WARN_ON(&a->table != table);
+ WARN_ON(&a->mapping != mapping);
- dma_unmap_sgtable(attachment->dev, table, direction,
- DMA_ATTR_SKIP_CPU_SYNC);
+ dma_unmap_sgtable(dma_buf_sgt_mapping_dma_device(mapping),
+ &mapping->sgt, direction, DMA_ATTR_SKIP_CPU_SYNC);
}
static void tee_heap_buf_free(struct dma_buf *dmabuf)
@@ -160,9 +162,9 @@ static void tee_heap_buf_free(struct dma_buf *dmabuf)
static const struct dma_buf_ops tee_heap_buf_ops = {
.attach = tee_heap_attach,
.detach = tee_heap_detach,
- .map_dma_buf = tee_heap_map_dma_buf,
- .unmap_dma_buf = tee_heap_unmap_dma_buf,
.release = tee_heap_buf_free,
+ DMA_BUF_SIMPLE_SGT_EXP_MATCH(tee_heap_map_dma_buf,
+ tee_heap_unmap_dma_buf),
};
static struct dma_buf *tee_dma_heap_alloc(struct dma_heap *heap,
diff --git a/drivers/xen/gntdev-dmabuf.c b/drivers/xen/gntdev-dmabuf.c
index e07e34515421..62ec297355a1 100644
--- a/drivers/xen/gntdev-dmabuf.c
+++ b/drivers/xen/gntdev-dmabuf.c
@@ -11,6 +11,7 @@
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/dma-buf.h>
+#include <linux/dma-buf-mapping.h>
#include <linux/dma-direct.h>
#include <linux/slab.h>
#include <linux/types.h>
@@ -62,7 +63,7 @@ struct gntdev_dmabuf_wait_obj {
};
struct gntdev_dmabuf_attachment {
- struct sg_table *sgt;
+ struct dma_buf_sgt_mapping *mapping;
enum dma_data_direction dir;
};
@@ -194,28 +195,28 @@ static int dmabuf_exp_wait_released(struct gntdev_dmabuf_priv *priv, int fd,
/* DMA buffer export support. */
-static struct sg_table *
+static struct dma_buf_sgt_mapping *
dmabuf_pages_to_sgt(struct page **pages, unsigned int nr_pages)
{
- struct sg_table *sgt;
+ struct dma_buf_sgt_mapping *mapping;
int ret;
- sgt = kmalloc_obj(*sgt);
- if (!sgt) {
+ mapping = kzalloc_obj(*mapping);
+ if (!mapping) {
ret = -ENOMEM;
goto out;
}
- ret = sg_alloc_table_from_pages(sgt, pages, nr_pages, 0,
+ ret = sg_alloc_table_from_pages(&mapping->sgt, pages, nr_pages, 0,
nr_pages << PAGE_SHIFT,
GFP_KERNEL);
if (ret)
goto out;
- return sgt;
+ return mapping;
out:
- kfree(sgt);
+ kfree(mapping);
return ERR_PTR(ret);
}
@@ -239,39 +240,43 @@ static void dmabuf_exp_ops_detach(struct dma_buf *dma_buf,
struct gntdev_dmabuf_attachment *gntdev_dmabuf_attach = attach->priv;
if (gntdev_dmabuf_attach) {
- struct sg_table *sgt = gntdev_dmabuf_attach->sgt;
+ struct dma_buf_sgt_mapping *mapping =
+ gntdev_dmabuf_attach->mapping;
+
+ if (mapping) {
+ struct device *dma_dev = dma_buf_sgt_dma_device(attach);
- if (sgt) {
if (gntdev_dmabuf_attach->dir != DMA_NONE)
- dma_unmap_sgtable(attach->dev, sgt,
+ dma_unmap_sgtable(dma_dev, &mapping->sgt,
gntdev_dmabuf_attach->dir,
DMA_ATTR_SKIP_CPU_SYNC);
- sg_free_table(sgt);
+ sg_free_table(&mapping->sgt);
}
- kfree(sgt);
+ kfree(mapping);
kfree(gntdev_dmabuf_attach);
attach->priv = NULL;
}
}
-static struct sg_table *
+static struct dma_buf_sgt_mapping *
dmabuf_exp_ops_map_dma_buf(struct dma_buf_attachment *attach,
enum dma_data_direction dir)
{
+ struct device *dma_dev = dma_buf_sgt_dma_device(attach);
struct gntdev_dmabuf_attachment *gntdev_dmabuf_attach = attach->priv;
struct gntdev_dmabuf *gntdev_dmabuf = attach->dmabuf->priv;
- struct sg_table *sgt;
+ struct dma_buf_sgt_mapping *mapping;
pr_debug("Mapping %d pages for dev %p\n", gntdev_dmabuf->nr_pages,
- attach->dev);
+ dma_dev);
if (dir == DMA_NONE || !gntdev_dmabuf_attach)
return ERR_PTR(-EINVAL);
/* Return the cached mapping when possible. */
if (gntdev_dmabuf_attach->dir == dir)
- return gntdev_dmabuf_attach->sgt;
+ return gntdev_dmabuf_attach->mapping;
/*
* Two mappings with different directions for the same attachment are
@@ -280,26 +285,26 @@ dmabuf_exp_ops_map_dma_buf(struct dma_buf_attachment *attach,
if (gntdev_dmabuf_attach->dir != DMA_NONE)
return ERR_PTR(-EBUSY);
- sgt = dmabuf_pages_to_sgt(gntdev_dmabuf->pages,
- gntdev_dmabuf->nr_pages);
- if (!IS_ERR(sgt)) {
- if (dma_map_sgtable(attach->dev, sgt, dir,
+ mapping = dmabuf_pages_to_sgt(gntdev_dmabuf->pages,
+ gntdev_dmabuf->nr_pages);
+ if (!IS_ERR(mapping)) {
+ if (dma_map_sgtable(dma_dev, &mapping->sgt, dir,
DMA_ATTR_SKIP_CPU_SYNC)) {
- sg_free_table(sgt);
- kfree(sgt);
- sgt = ERR_PTR(-ENOMEM);
+ sg_free_table(&mapping->sgt);
+ kfree(mapping);
+ mapping = ERR_PTR(-ENOMEM);
} else {
- gntdev_dmabuf_attach->sgt = sgt;
+ gntdev_dmabuf_attach->mapping = mapping;
gntdev_dmabuf_attach->dir = dir;
}
}
- if (IS_ERR(sgt))
- pr_debug("Failed to map sg table for dev %p\n", attach->dev);
- return sgt;
+ if (IS_ERR(mapping))
+ pr_debug("Failed to map sg table for dev %p\n", dma_dev);
+ return mapping;
}
static void dmabuf_exp_ops_unmap_dma_buf(struct dma_buf_attachment *attach,
- struct sg_table *sgt,
+ struct dma_buf_sgt_mapping *mapping,
enum dma_data_direction dir)
{
/* Not implemented. The unmap is done at dmabuf_exp_ops_detach(). */
@@ -340,9 +345,9 @@ static void dmabuf_exp_ops_release(struct dma_buf *dma_buf)
static const struct dma_buf_ops dmabuf_exp_ops = {
.attach = dmabuf_exp_ops_attach,
.detach = dmabuf_exp_ops_detach,
- .map_dma_buf = dmabuf_exp_ops_map_dma_buf,
- .unmap_dma_buf = dmabuf_exp_ops_unmap_dma_buf,
.release = dmabuf_exp_ops_release,
+ DMA_BUF_SIMPLE_SGT_EXP_MATCH(dmabuf_exp_ops_map_dma_buf,
+ dmabuf_exp_ops_unmap_dma_buf),
};
struct gntdev_dmabuf_export_args {
--
2.54.0
next prev parent reply other threads:[~2026-11-20 5:57 UTC|newest]
Thread overview: 25+ 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 5:55 ` [PATCH v3 08/24] iommufd/selftest: Convert the test exporter " Alistair Popple
2026-11-20 5:55 ` Alistair Popple [this message]
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=20261120-dma_mapping_type_v4-v3-9-c0183a409bdf@nvidia.com \
--to=apopple@nvidia.com \
--cc=aik@amd.com \
--cc=alexander.deucher@amd.com \
--cc=almasrymina@google.com \
--cc=amd-gfx@lists.freedesktop.org \
--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
all inboxes | Powered by JetHome®