[PATCH] dma-buf: refcount the attachment for cache_sgt_mapping

Nicolin Chen
2019-06-12T01:22:19Z

Commit f13e143e7444 ("dma-buf: start caching of sg_table objects v2")
added a support of caching the sgt pointer into an attach pointer to
let users reuse the sgt pointer without another mapping. However, it
might not totally work as most of dma-buf callers are doing attach()
and map_attachment() back-to-back, using drm_prime.c for example:
drm_gem_prime_import_dev() {
attach = dma_buf_attach() {
/* Allocating a new attach */
attach = kzalloc();
/* .... */
return attach;
}
dma_buf_map_attachment(attach, direction) {
/* attach->sgt would be always empty as attach is new */
if (attach->sgt) {
/* Reuse attach->sgt */
}
/* Otherwise, map it */
attach->sgt = map();
}
}

So, for a cache_sgt_mapping use case, it would need to get the same
attachment pointer in order to reuse its sgt pointer. So this patch
adds a refcount to the attach() function and lets it search for the
existing attach pointer by matching the dev pointer.

Signed-off-by: Nicolin Chen <nicoleotsuka@gmail.com>
---
drivers/dma-buf/dma-buf.c | 23 +++++++++++++++++++++++
include/linux/dma-buf.h | 2 ++
2 files changed, 25 insertions(+)

diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c
index f4104a21b069..d0260553a31c 100644
--- a/drivers/dma-buf/dma-buf.c
+++ b/drivers/dma-buf/dma-buf.c
@@ -559,6 +559,21 @@ struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf,
if (WARN_ON(!dmabuf || !dev))
return ERR_PTR(-EINVAL);

+ /* cache_sgt_mapping requires to reuse the same attachment pointer */
+ if (dmabuf->ops->cache_sgt_mapping) {
+ mutex_lock(&dmabuf->lock);
+
+ /* Search for existing attachment and increase its refcount */
+ list_for_each_entry(attach, &dmabuf->attachments, node) {
+ if (dev != attach->dev)
+ continue;
+ atomic_inc_not_zero(&attach->refcount);
+ goto unlock_attach;
+ }
+
+ mutex_unlock(&dmabuf->lock);
+ }
+
attach = kzalloc(sizeof(*attach), GFP_KERNEL);
if (!attach)
return ERR_PTR(-ENOMEM);
@@ -575,6 +590,9 @@ struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf,
}
list_add(&attach->node, &dmabuf->attachments);

+ atomic_set(&attach->refcount, 1);
+
+unlock_attach:
mutex_unlock(&dmabuf->lock);

return attach;
@@ -599,6 +617,11 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach)
if (WARN_ON(!dmabuf || !attach))
return;

+ /* Decrease the refcount for cache_sgt_mapping use cases */
+ if (dmabuf->ops->cache_sgt_mapping &&
+ atomic_dec_return(&attach->refcount))
+ return;
+
if (attach->sgt)
dmabuf->ops->unmap_dma_buf(attach, attach->sgt, attach->dir);

diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
index 8a327566d7f4..65f12212ca2e 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -333,6 +333,7 @@ struct dma_buf {
* @dev: device attached to the buffer.
* @node: list of dma_buf_attachment.
* @sgt: cached mapping.
+ * @refcount: refcount of the attachment for the same device.
* @dir: direction of cached mapping.
* @priv: exporter specific attachment data.
*
@@ -350,6 +351,7 @@ struct dma_buf_attachment {
struct device *dev;
struct list_head node;
struct sg_table *sgt;
+ atomic_t refcount;
enum dma_data_direction dir;
void *priv;
};
--
2.17.1