[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