lkml.org 
[lkml]   [2019]   [Sep]   [6]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[RESEND][PATCH v8 3/5] dma-buf: heaps: Add system heap to dmabuf heaps
    Date
    This patch adds system heap to the dma-buf heaps framework.

    This allows applications to get a page-allocator backed dma-buf
    for non-contiguous memory.

    This code is an evolution of the Android ION implementation, so
    thanks to its original authors and maintainters:
    Rebecca Schultz Zavin, Colin Cross, Laura Abbott, and others!

    Cc: Laura Abbott <labbott@redhat.com>
    Cc: Benjamin Gaignard <benjamin.gaignard@linaro.org>
    Cc: Sumit Semwal <sumit.semwal@linaro.org>
    Cc: Liam Mark <lmark@codeaurora.org>
    Cc: Pratik Patel <pratikp@codeaurora.org>
    Cc: Brian Starkey <Brian.Starkey@arm.com>
    Cc: Vincent Donnefort <Vincent.Donnefort@arm.com>
    Cc: Sudipto Paul <Sudipto.Paul@arm.com>
    Cc: Andrew F. Davis <afd@ti.com>
    Cc: Christoph Hellwig <hch@infradead.org>
    Cc: Chenbo Feng <fengc@google.com>
    Cc: Alistair Strachan <astrachan@google.com>
    Cc: Hridya Valsaraju <hridya@google.com>
    Cc: dri-devel@lists.freedesktop.org
    Reviewed-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
    Signed-off-by: John Stultz <john.stultz@linaro.org>
    ---
    v2:
    * Switch allocate to return dmabuf fd
    * Simplify init code
    * Checkpatch fixups
    * Droped dead system-contig code
    v3:
    * Whitespace fixups from Benjamin
    * Make sure we're zeroing the allocated pages (from Liam)
    * Use PAGE_ALIGN() consistently (suggested by Brian)
    * Fold in new registration style from Andrew
    * Avoid needless dynamic allocation of sys_heap (suggested by
    Christoph)
    * Minor cleanups
    * Folded in changes from Andrew to use simplified page list
    from the heap helpers
    v4:
    * Optimization to allocate pages in chunks, similar to old
    pagepool code
    * Use fd_flags when creating dmabuf fd (Suggested by Benjamin)
    v5:
    * Back out large order page allocations (was leaking memory,
    as the page array didn't properly track order size)
    v6:
    * Minor whitespace change suggested by Brian
    * Remove unused variable
    v7:
    * Use newly lower-cased init_heap_helper_buffer helper
    * Add system heap DOS avoidance suggested by Laura from ION code
    * Use new dmabuf export helper
    v8:
    * Make struct dma_heap_ops consts (suggested by Christoph)
    * Get rid of needless struct system_heap (suggested by Christoph)
    * Condense dma_heap_buffer and heap_helper_buffer (suggested by
    Christoph)
    * Add forgotten include file to fix build issue on x86
    ---
    drivers/dma-buf/Kconfig | 2 +
    drivers/dma-buf/heaps/Kconfig | 6 ++
    drivers/dma-buf/heaps/Makefile | 1 +
    drivers/dma-buf/heaps/system_heap.c | 122 ++++++++++++++++++++++++++++
    4 files changed, 131 insertions(+)
    create mode 100644 drivers/dma-buf/heaps/Kconfig
    create mode 100644 drivers/dma-buf/heaps/system_heap.c

    diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig
    index 162e24e1e429..657ce743abda 100644
    --- a/drivers/dma-buf/Kconfig
    +++ b/drivers/dma-buf/Kconfig
    @@ -48,4 +48,6 @@ menuconfig DMABUF_HEAPS
    allows userspace to use to allocate dma-bufs that can be shared
    between drivers.

    +source "drivers/dma-buf/heaps/Kconfig"
    +
    endmenu
    diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig
    new file mode 100644
    index 000000000000..205052744169
    --- /dev/null
    +++ b/drivers/dma-buf/heaps/Kconfig
    @@ -0,0 +1,6 @@
    +config DMABUF_HEAPS_SYSTEM
    + bool "DMA-BUF System Heap"
    + depends on DMABUF_HEAPS
    + help
    + Choose this option to enable the system dmabuf heap. The system heap
    + is backed by pages from the buddy allocator. If in doubt, say Y.
    diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile
    index de49898112db..d1808eca2581 100644
    --- a/drivers/dma-buf/heaps/Makefile
    +++ b/drivers/dma-buf/heaps/Makefile
    @@ -1,2 +1,3 @@
    # SPDX-License-Identifier: GPL-2.0
    obj-y += heap-helpers.o
    +obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o
    diff --git a/drivers/dma-buf/heaps/system_heap.c b/drivers/dma-buf/heaps/system_heap.c
    new file mode 100644
    index 000000000000..5db4ef9b4afc
    --- /dev/null
    +++ b/drivers/dma-buf/heaps/system_heap.c
    @@ -0,0 +1,122 @@
    +// SPDX-License-Identifier: GPL-2.0
    +/*
    + * DMABUF System heap exporter
    + *
    + * Copyright (C) 2011 Google, Inc.
    + * Copyright (C) 2019 Linaro Ltd.
    + */
    +
    +#include <asm/page.h>
    +#include <linux/dma-buf.h>
    +#include <linux/dma-mapping.h>
    +#include <linux/dma-heap.h>
    +#include <linux/err.h>
    +#include <linux/highmem.h>
    +#include <linux/mm.h>
    +#include <linux/scatterlist.h>
    +#include <linux/slab.h>
    +#include <linux/sched/signal.h>
    +
    +#include "heap-helpers.h"
    +
    +struct dma_heap *sys_heap;
    +
    +static void system_heap_free(struct heap_helper_buffer *buffer)
    +{
    + pgoff_t pg;
    +
    + for (pg = 0; pg < buffer->pagecount; pg++)
    + __free_page(buffer->pages[pg]);
    + kfree(buffer->pages);
    + kfree(buffer);
    +}
    +
    +static int system_heap_allocate(struct dma_heap *heap,
    + unsigned long len,
    + unsigned long fd_flags,
    + unsigned long heap_flags)
    +{
    + struct heap_helper_buffer *helper_buffer;
    + struct dma_buf *dmabuf;
    + int ret = -ENOMEM;
    + pgoff_t pg;
    +
    + helper_buffer = kzalloc(sizeof(*helper_buffer), GFP_KERNEL);
    + if (!helper_buffer)
    + return -ENOMEM;
    +
    + init_heap_helper_buffer(helper_buffer, system_heap_free);
    + helper_buffer->flags = heap_flags;
    + helper_buffer->heap = heap;
    + helper_buffer->size = len;
    +
    + helper_buffer->pagecount = len / PAGE_SIZE;
    + helper_buffer->pages = kmalloc_array(helper_buffer->pagecount,
    + sizeof(*helper_buffer->pages),
    + GFP_KERNEL);
    + if (!helper_buffer->pages) {
    + ret = -ENOMEM;
    + goto err0;
    + }
    +
    + for (pg = 0; pg < helper_buffer->pagecount; pg++) {
    + /*
    + * Avoid trying to allocate memory if the process
    + * has been killed by by SIGKILL
    + */
    + if (fatal_signal_pending(current))
    + goto err1;
    +
    + helper_buffer->pages[pg] = alloc_page(GFP_KERNEL | __GFP_ZERO);
    + if (!helper_buffer->pages[pg])
    + goto err1;
    + }
    +
    + /* create the dmabuf */
    + dmabuf = heap_helper_export_dmabuf(helper_buffer, fd_flags);
    + if (IS_ERR(dmabuf)) {
    + ret = PTR_ERR(dmabuf);
    + goto err1;
    + }
    +
    + helper_buffer->dmabuf = dmabuf;
    +
    + ret = dma_buf_fd(dmabuf, fd_flags);
    + if (ret < 0) {
    + dma_buf_put(dmabuf);
    + /* just return, as put will call release and that will free */
    + return ret;
    + }
    +
    + return ret;
    +
    +err1:
    + while (pg > 0)
    + __free_page(helper_buffer->pages[--pg]);
    + kfree(helper_buffer->pages);
    +err0:
    + kfree(helper_buffer);
    +
    + return -ENOMEM;
    +}
    +
    +static const struct dma_heap_ops system_heap_ops = {
    + .allocate = system_heap_allocate,
    +};
    +
    +static int system_heap_create(void)
    +{
    + struct dma_heap_export_info exp_info;
    + int ret = 0;
    +
    + exp_info.name = "system_heap";
    + exp_info.ops = &system_heap_ops;
    + exp_info.priv = NULL;
    +
    + sys_heap = dma_heap_add(&exp_info);
    + if (IS_ERR(sys_heap))
    + ret = PTR_ERR(sys_heap);
    +
    + return ret;
    +}
    +device_initcall(system_heap_create);
    --
    2.17.1
    \
     
     \ /
      Last update: 2019-09-06 20:48    [W:2.568 / U:0.536 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site