[PATCH v3 09/24] dma-buf: Convert exporters keeping a table per attachment to the SGT mapping type

From: Alistair Popple

Date: Fri Nov 20 2026 - 00:59:13 EST


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@xxxxxxxxxx>
Signed-off-by: Jason Gunthorpe <jgg@xxxxxxxxxx>
Signed-off-by: Alistair Popple <apopple@xxxxxxxxxx>
---
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