[Linaro-mm-sig] [RFC] dma-shared-buf: Add buffer sharing framework

Sumit Semwal sumit.semwal at ti.com
Wed Aug 10 12:11:04 UTC 2011


This RFC is aimed at introducing the buffer sharing framework for review.

Since almost all the discussion about buffer sharing objects happened on
linaro-mm-sig list, I am sending it first for review within the list, and
will share it with other lists after first-set of review comments from here.

--

This is the first step in defining a buffer sharing framework.
A new buffer object is added, with hooks to allow for easy sharing of
this buffer object across devices.

The idea was first mooted at the Linaro memory management mini-summit in
Budapest in May 2011, as part of multiple things needed for a 'unified memory
management framework'. It took a more concrete shape at Linaro memory-management
mini-summit in Cambridge, Aug 2011.

The framework allows:
- a new buffer-object to be created, which associates a file pointer with each
   user-buffer and associated allocator-defined operations on that buffer.
   This operation is called the 'export' operation.
- this exported buffer-object to be shared with the other entity by asking for
   its 'file-descriptor (fd)', and sharing the fd across.
- a received fd to get the buffer object back, where it can be accessed using
   the associated allocator-defined operations.
- the exporter and importer to share the scatterlist using get_ and put_
   operations.

Some file operations are provided as wrappers over the allocator-defined
operations, which allows usage of fops(eg mmap) on the associated 'fd'.

This is based on design suggestions from many people at both the mini-summits,
most notably from Arnd Bergmann <arnd at arndb.de>, and Rob Clark <rob at ti.com>.

The implementation is inspired from proof-of-concept patch-set from
Tomasz Stanislawski <t.stanislaws at samsung.com>, who demonstrated buffer sharing
between two v4l2 devices.

Signed-off-by: Sumit Semwal <sumit.semwal at ti.com>
---
 drivers/base/Kconfig    |   10 +++
 drivers/base/Makefile   |    1 +
 drivers/base/dma-buf.c  |  196 +++++++++++++++++++++++++++++++++++++++++++++++
 include/linux/dma-buf.h |  105 +++++++++++++++++++++++++
 4 files changed, 312 insertions(+), 0 deletions(-)
 create mode 100644 drivers/base/dma-buf.c
 create mode 100644 include/linux/dma-buf.h

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index d57e8d0..5398ce8 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -168,4 +168,14 @@ config SYS_HYPERVISOR
 	bool
 	default n
 
+config DMA_SHARED_BUFFER
+	bool "Buffer framework to be shared between drivers"
+	default n
+	depends on ANON_INODES
+	help
+	  This option enables the framework for buffer-sharing between
+	  multiple drivers. A buffer is associated with a file using driver
+	  APIs extension; the file's descriptor can then be passed on to other
+	  driver.
+
 endmenu
diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 4c5701c..bd95732 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_DEVTMPFS)	+= devtmpfs.o
 obj-y			+= power/
 obj-$(CONFIG_HAS_DMA)	+= dma-mapping.o
 obj-$(CONFIG_HAVE_GENERIC_DMA_COHERENT) += dma-coherent.o
+obj-$(CONFIG_DMA_SHARED_BUFFER) += dma-buf.o
 obj-$(CONFIG_ISA)	+= isa.o
 obj-$(CONFIG_FW_LOADER)	+= firmware_class.o
 obj-$(CONFIG_NUMA)	+= node.o
diff --git a/drivers/base/dma-buf.c b/drivers/base/dma-buf.c
new file mode 100644
index 0000000..e35b385
--- /dev/null
+++ b/drivers/base/dma-buf.c
@@ -0,0 +1,196 @@
+/*
+ * Framework for buffer objects that can be shared across devices/subsystems.
+ *
+ * Copyright(C) 2011 Texas Instruments Inc. All rights reserved.
+ * Author: Sumit Semwal <sumit.semwal at ti.com>
+ *
+ * Many thanks to linaro-mm-sig list, and specially
+ * Arnd Bergmann <arnd at arndb.de> and Rob Clark <rob at ti.com>
+ * for their support in creation and refining of this idea.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/dma-buf.h>
+#include <linux/anon_inodes.h>
+
+static int is_dma_buf_file(struct file *);
+
+/* file operation wrappers for dma buf ops */
+static ssize_t dma_buf_read(struct file *file, char __user *buf, size_t size,
+				loff_t *offset)
+{
+	struct dma_buf *dmabuf;
+
+	if (!is_dma_buf_file(file))
+		return -EINVAL;
+
+	dmabuf = file->private_data;
+	return dmabuf->ops->read(dmabuf, buf, size);
+}
+
+static ssize_t dma_buf_write(struct file *file, char __user *buf, size_t size,
+				loff_t *offset)
+{
+	struct dma_buf *dmabuf;
+
+	if (!is_dma_buf_file(file))
+		return -EINVAL;
+
+	dmabuf = file->private_data;
+	return dmabuf->ops->write(dmabuf, buf, size);
+}
+
+static int dma_buf_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	struct dma_buf *dmabuf;
+
+	if (!is_dma_buf_file(file))
+		return -EINVAL;
+
+	dmabuf = file->private_data;
+	return dmabuf->ops->mmap(dmabuf, vma);
+}
+
+static int dma_buf_release(struct inode *inode, struct file *file)
+{
+	struct dma_buf *dmabuf;
+
+	if (!is_dma_buf_file(file))
+		return -EINVAL;
+
+	dmabuf = file->private_data;
+
+	dmabuf->ops->release(dmabuf);
+	kfree(dmabuf);
+	return 0;
+}
+
+static const struct file_operations dma_buf_fops = {
+	.mmap		= dma_buf_mmap,
+	.read		= dma_buf_read,
+	.write		= dma_buf_write,
+	.release	= dma_buf_release,
+};
+
+/*
+ * is_dma_buf_file - Check if struct file* is associated with dma_buf
+ */
+static inline int is_dma_buf_file(struct file *file)
+{
+	return file->f_op == &dma_buf_fops;
+}
+
+/**
+ * dma_buf_export - Creates a new dma_buf, and associates an anon file
+ * with this buffer,so it can be exported.
+ * Also 'attach' the allocator specific data and ops to the buffer.
+ *
+ * @priv:	Attach private data of allocator to this buffer
+ * @ops:	Attach allocator-defined dma buf ops to the new buffer.
+ *
+ * Returns, on success, a newly created dma_buf object, which wraps the
+ * supplied private data and operations for dma_buf_ops. On failure to
+ * allocate the dma_buf object, it can return NULL.
+ *
+ */
+struct dma_buf *dma_buf_export(void *priv, struct dma_buf_ops *ops)
+{
+	struct dma_buf *dmabuf;
+	struct file *file;
+
+	BUG_ON(!priv || !ops);
+
+	dmabuf = kzalloc(sizeof(struct dma_buf), GFP_KERNEL);
+	if (dmabuf == NULL)
+		return dmabuf;
+
+	dmabuf->priv = priv;
+	dmabuf->ops = ops;
+
+	file = anon_inode_getfile("dmabuf", &dma_buf_fops, dmabuf, 0);
+
+	dmabuf->file = file;
+	file->private_data = dmabuf;
+
+	return dmabuf;
+}
+EXPORT_SYMBOL(dma_buf_export);
+
+/**
+ * dma_buf_fd - returns a file descriptor for the given dma_buf
+ * @dmabuf:	[in]	pointer to dma_buf for which fd is required.
+ *
+ * On success, returns an associated 'fd'. Else, returns error.
+ */
+int dma_buf_fd(struct dma_buf *dmabuf)
+{
+	int error, fd;
+
+	if (!dmabuf->file)
+		return -EINVAL;
+
+	error = get_unused_fd_flags(0);
+	if (error < 0)
+		return error;
+	fd = error;
+
+	fd_install(fd, dmabuf->file);
+
+	return fd;
+}
+EXPORT_SYMBOL(dma_buf_fd);
+
+/**
+ * dma_buf_get - returns the dma_buf structure related to an fd
+ * @fd:	[in]	fd associated with the dma_buf to be returned
+ *
+ * On success, returns the dma_buf structure associated with an fd; uses
+ * file's refcounting done by fget to increase refcount. returns ERR_PTR
+ * otherwise.
+ */
+struct dma_buf *dma_buf_get(int fd)
+{
+	struct file *file;
+
+	file = fget(fd);
+
+	if (!file)
+		return ERR_PTR(-EBADF);
+
+	if (!is_dma_buf_file(file)) {
+		fput(file);
+		return ERR_PTR(-EINVAL);
+	}
+
+	return file->private_data;
+}
+EXPORT_SYMBOL(dma_buf_get);
+
+/**
+ * dma_buf_put - decreases refcount of the buffer
+ * @dmabuf:	[in]	buffer to reduce refcount of
+ *
+ * Uses file's refcounting done implicitly by fput()
+ */
+void dma_buf_put(struct dma_buf *dmabuf)
+{
+	BUG_ON(!dmabuf->file);
+
+	fput(dmabuf->file);
+
+	return;
+}
+EXPORT_SYMBOL(dma_buf_put);
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
new file mode 100644
index 0000000..c22896a
--- /dev/null
+++ b/include/linux/dma-buf.h
@@ -0,0 +1,105 @@
+/*
+ * Header file for dma buffer sharing framework.
+ *
+ * Copyright(C) 2011 Texas Instruments Inc. All rights reserved.
+ * Author: Sumit Semwal <sumit.semwal at ti.com>
+ *
+ * Many thanks to linaro-mm-sig list, and specially
+ * Arnd Bergmann <arnd at arndb.de> and Rob Clark <rob at ti.com>
+ * for their support in creation and refining of this idea.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __DMA_BUF_H__
+#define __DMA_BUF_H__
+
+#include <linux/file.h>
+#include <linux/err.h>
+#include <linux/device.h>
+#include <linux/scatterlist.h>
+
+struct dma_buf;
+
+/**
+ * struct dma_buf_ops - operations possible on struct dmabuf
+ * @get_scatterlist: returns list of scatter pages allocated, increases
+ *		     usecount of the buffer
+ * @put_scatterlist: decreases usecount of buffer, might deallocate scatter
+ *		     pages
+ * @mmap: map this buffer
+ * @read: read from this buffer
+ * @write: write to this buffer
+ * @release: release this buffer; to be called after the last dma_buf_put
+ * @sync_sg_for_cpu: sync the sg list for cpu
+ * @sync_sg_for_device: synch the sg list for device
+ */
+struct dma_buf_ops {
+	/* allow buffer to not be pinned when DMA is not happening */
+	struct scatterlist * (*get_scatterlist)(struct dma_buf *);
+	void (*put_scatterlist)(struct dma_buf *, struct scatterlist *);
+
+	/* allow allocator to mmap/read/write to take care of cache attrib */
+	int (*mmap)(struct dma_buf *, struct vm_area_struct *);
+	ssize_t (*read)(struct dma_buf *, void *, size_t);
+	ssize_t (*write)(struct dma_buf *, void *, size_t);
+	/* after final dma_buf_put() */
+	void (*release)(struct dma_buf *);
+
+	/* allow allocator to take care of cache ops */
+	void (*sync_sg_for_cpu) (struct dma_buf *, struct device *);
+	void (*sync_sg_for_device)(struct dma_buf *, struct device *);
+};
+
+/**
+ * struct dma_buf - shared buffer object
+ * @file: file pointer used for sharing buffers across, and for refcounting.
+ * @ops: dma_buf_ops associated with this buffer object
+ * @priv: user specific private data
+ */
+struct dma_buf {
+	struct file *file;
+	struct dma_buf_ops *ops;
+	void *priv;
+};
+
+#ifdef CONFIG_DMA_SHARED_BUFFER
+
+struct dma_buf *dma_buf_export(void *priv, struct dma_buf_ops *ops);
+int dma_buf_fd(struct dma_buf *dmabuf);
+struct dma_buf *dma_buf_get(int fd);
+void dma_buf_put(struct dma_buf *dmabuf);
+
+#else
+static inline struct dma_buf *dma_buf_export(void *priv,
+						struct dma_buf_ops *ops)
+{
+	return ERR_PTR(-ENODEV);
+}
+
+static inline int dma_buf_fd(struct dma_buf *dmabuf)
+{
+	return -ENODEV;
+}
+
+static inline struct dma_buf *dma_buf_get(int fd)
+{
+	return ERR_PTR(-ENODEV);
+}
+
+static inline void dma_buf_put(struct dma_buf *dmabuf)
+{
+	return;
+}
+#endif /* CONFIG_DMA_SHARED_BUFFER */
+
+#endif /* __DMA_BUF_H__ */
-- 
1.7.4.1




More information about the Linaro-mm-sig mailing list