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

On Wednesday, August 10, 2011 14:11:04 Sumit Semwal wrote:

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@arndb.de, and Rob Clark rob@ti.com.

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

Signed-off-by: Sumit Semwal sumit.semwal@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@ti.com
• • Many thanks to linaro-mm-sig list, and specially
• • Arnd Bergmann arnd@arndb.de and Rob Clark rob@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);

The 'read' ops should be optional. Not all drivers will support this.

+}

+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);

Ditto for write...

+}

+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);

...and mmap.

I would expect to see an ioctl op as well, if only to pass the size of the buffer back to userspace.

And if we support read/write, then we need a seek as well.

Frankly, I'm not sure about the read and write. I don't really see the use case. The whole point of buffer sharing is to avoid copying buffers, and that's exactly what read and write do.

+}

+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@ti.com
• • Many thanks to linaro-mm-sig list, and specially
• • Arnd Bergmann arnd@arndb.de and Rob Clark rob@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__ */

Regards,

Hans