Series comparison

-[PATCH v2 0/2] dma-buf: heaps: Support carved-out heaps
+[PATCH v3 0/2] dma-buf: heaps: Support carved-out heaps
 ...
 Let me know what you think,
 Maxime
 Signed-off-by: Maxime Ripard <mripard@kernel.org>
 ---
+Changes in v3:
+- Reworked global variable patch
+- Link to v2: https://lore.kernel.org/r/20250401-dma-buf-ecc-heap-v2-0-043fd006a1af@kernel.org
 Changes in v2:
 - Add vmap/vunmap operations
 - Drop ECC flags uapi
 - Rebase on top of 6.14
 - Link to v1: https://lore.kernel.org/r/20240515-dma-buf-ecc-heap-v1-0-54cbbd049511@kernel.org
 ...
       dma-buf: heaps: Introduce a new heap for reserved memory
  drivers/dma-buf/heaps/Kconfig         |   8 +
  drivers/dma-buf/heaps/Makefile        |   1 +
  drivers/dma-buf/heaps/carveout_heap.c | 360 ++++++++++++++++++++++++++++++++++
- drivers/dma-buf/heaps/system_heap.c   |  17 +-
+ drivers/dma-buf/heaps/system_heap.c   |   3 +-
-files changed, 381 insertions(+), 5 deletions(-)
+files changed, 370 insertions(+), 2 deletions(-)
 ---
 base-commit: fcbf30774e82a441890b722bf0c26542fb82150f
 change-id: 20240515-dma-buf-ecc-heap-28a311d2c94e
 Best regards,
 --
 Maxime Ripard <mripard@kernel.org>

-[PATCH v2 1/2] dma-buf: heaps: system: Remove global variable
+[PATCH v3 1/2] dma-buf: heaps: system: Remove global variable
-The system heap has been using its struct dma_heap pointer but wasn't
+The system heap is storing its struct dma_heap pointer in a global
-using it anywhere.
+variable but isn't using it anywhere.
-Since we'll need additional parameters to attach to that heap type,
+Let's move the global variable into system_heap_create() to make it
-let's create a private structure and set it as the dma_heap drvdata,
+local.
 removing the global variable in the process.
 Signed-off-by: Maxime Ripard <mripard@kernel.org>
 ---
- drivers/dma-buf/heaps/system_heap.c | 17 ++++++++++++-----
+ drivers/dma-buf/heaps/system_heap.c | 3 +--
-file changed, 12 insertions(+), 5 deletions(-)
+file changed, 1 insertion(+), 2 deletions(-)
 diff --git a/drivers/dma-buf/heaps/system_heap.c b/drivers/dma-buf/heaps/system_heap.c
 index XXXXXXX..XXXXXXX 100644
 --- a/drivers/dma-buf/heaps/system_heap.c
 +++ b/drivers/dma-buf/heaps/system_heap.c
 ...
  #include <linux/scatterlist.h>
  #include <linux/slab.h>
  #include <linux/vmalloc.h>
 -static struct dma_heap *sys_heap;
-+struct system_heap {
+-
 +    struct dma_heap *heap;
 +};
  struct system_heap_buffer {
      struct dma_heap *heap;
      struct list_head attachments;
      struct mutex lock;
+     unsigned long len;
 @@ -XXX,XX +XXX,XX @@ static const struct dma_heap_ops system_heap_ops = {
  };
  static int __init system_heap_create(void)
  {
      struct dma_heap_export_info exp_info;
-+    struct system_heap *sys_heap;
++    struct dma_heap *sys_heap;
 +
 +    sys_heap = kzalloc(sizeof(*sys_heap), GFP_KERNEL);
 +    if (!sys_heap)
 +        return -ENOMEM;
      exp_info.name = "system";
      exp_info.ops = &system_heap_ops;
--    exp_info.priv = NULL;
+     exp_info.priv = NULL;
-+    exp_info.priv = sys_heap;
 -    sys_heap = dma_heap_add(&exp_info);
 -    if (IS_ERR(sys_heap))
 -        return PTR_ERR(sys_heap);
 +    sys_heap->heap = dma_heap_add(&exp_info);
 +    if (IS_ERR(sys_heap->heap))
 +        return PTR_ERR(sys_heap->heap);
      return 0;
  }
  module_init(system_heap_create);
 --
 .49.0

-[PATCH v2 2/2] dma-buf: heaps: Introduce a new heap for reserved memory
+[PATCH v3 2/2] dma-buf: heaps: Introduce a new heap for reserved memory
 Some reserved memory regions might have particular memory setup or
 attributes that make them good candidates for heaps.
 Let's provide a heap type that will create a new heap for each reserved
 memory region flagged as such.
 Signed-off-by: Maxime Ripard <mripard@kernel.org>
 ---
  drivers/dma-buf/heaps/Kconfig         |   8 +
  drivers/dma-buf/heaps/Makefile        |   1 +
  drivers/dma-buf/heaps/carveout_heap.c | 360 ++++++++++++++++++++++++++++++++++
 files changed, 369 insertions(+)
 diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig
 index XXXXXXX..XXXXXXX 100644
 --- a/drivers/dma-buf/heaps/Kconfig
 +++ b/drivers/dma-buf/heaps/Kconfig
 @@ -XXX,XX +XXX,XX @@
 +config DMABUF_HEAPS_CARVEOUT
 +    bool "Carveout Heaps"
 +    depends on DMABUF_HEAPS
 +    help
 +      Choose this option to enable the carveout dmabuf heap. The carveout
 +      heap is backed by pages from reserved memory regions flagged as
 +      exportable. If in doubt, say Y.
 +
  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
 diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile
 index XXXXXXX..XXXXXXX 100644
 --- a/drivers/dma-buf/heaps/Makefile
 +++ b/drivers/dma-buf/heaps/Makefile
 @@ -XXX,XX +XXX,XX @@
  # SPDX-License-Identifier: GPL-2.0
 +obj-$(CONFIG_DMABUF_HEAPS_CARVEOUT)    += carveout_heap.o
  obj-$(CONFIG_DMABUF_HEAPS_SYSTEM)    += system_heap.o
  obj-$(CONFIG_DMABUF_HEAPS_CMA)        += cma_heap.o
 diff --git a/drivers/dma-buf/heaps/carveout_heap.c b/drivers/dma-buf/heaps/carveout_heap.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/drivers/dma-buf/heaps/carveout_heap.c
 @@ -XXX,XX +XXX,XX @@
 +// SPDX-License-Identifier: GPL-2.0
 +
 +#include <linux/dma-buf.h>
 +#include <linux/dma-heap.h>
 +#include <linux/genalloc.h>
 +#include <linux/highmem.h>
 +#include <linux/of_reserved_mem.h>
 +
 +struct carveout_heap_priv {
 +    struct dma_heap *heap;
 +    struct gen_pool *pool;
 +};
 +
 +struct carveout_heap_buffer_priv {
 +    struct mutex lock;
 +    struct list_head attachments;
 +
 +    unsigned long num_pages;
 +    struct carveout_heap_priv *heap;
 +    dma_addr_t daddr;
 +    void *vaddr;
 +    unsigned int vmap_cnt;
 +};
 +
 +struct carveout_heap_attachment {
 +    struct list_head head;
 +    struct sg_table table;
 +
 +    struct device *dev;
 +    bool mapped;
 +};
 +
 +static int carveout_heap_attach(struct dma_buf *buf,
 +                struct dma_buf_attachment *attachment)
 +{
 +    struct carveout_heap_buffer_priv *priv = buf->priv;
 +    struct carveout_heap_attachment *a;
 +    struct sg_table *sgt;
 +    unsigned long len = priv->num_pages * PAGE_SIZE;
 +    int ret;
 +
 +    a = kzalloc(sizeof(*a), GFP_KERNEL);
 +    if (!a)
 +        return -ENOMEM;
 +    INIT_LIST_HEAD(&a->head);
 +    a->dev = attachment->dev;
 +    attachment->priv = a;
 +
 +    sgt = &a->table;
 +    ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
 +    if (ret)
 +        goto err_cleanup_attach;
 +
 +    sg_dma_address(sgt->sgl) = priv->daddr;
 +    sg_dma_len(sgt->sgl) = len;
 +
 +    mutex_lock(&priv->lock);
 +    list_add(&a->head, &priv->attachments);
 +    mutex_unlock(&priv->lock);
 +
 +    return 0;
 +
 +err_cleanup_attach:
 +    kfree(a);
 +    return ret;
 +}
 +
 +static void carveout_heap_detach(struct dma_buf *dmabuf,
 +                 struct dma_buf_attachment *attachment)
 +{
 +    struct carveout_heap_buffer_priv *priv = dmabuf->priv;
 +    struct carveout_heap_attachment *a = attachment->priv;
 +
 +    mutex_lock(&priv->lock);
 +    list_del(&a->head);
 +    mutex_unlock(&priv->lock);
 +
 +    sg_free_table(&a->table);
 +    kfree(a);
 +}
 +
 +static struct sg_table *
 +carveout_heap_map_dma_buf(struct dma_buf_attachment *attachment,
 +              enum dma_data_direction direction)
 +{
 +    struct carveout_heap_attachment *a = attachment->priv;
 +    struct sg_table *table = &a->table;
 +    int ret;
 +
 +    ret = dma_map_sgtable(a->dev, table, direction, 0);
 +    if (ret)
 +        return ERR_PTR(-ENOMEM);
 +
 +    a->mapped = true;
 +
 +    return table;
 +}
 +
 +static void carveout_heap_unmap_dma_buf(struct dma_buf_attachment *attachment,
 +                    struct sg_table *table,
 +                    enum dma_data_direction direction)
 +{
 +    struct carveout_heap_attachment *a = attachment->priv;
 +
 +    a->mapped = false;
 +    dma_unmap_sgtable(a->dev, table, direction, 0);
 +}
 +
 +static int
 +carveout_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
 +                       enum dma_data_direction direction)
 +{
 +    struct carveout_heap_buffer_priv *priv = dmabuf->priv;
 +    struct carveout_heap_attachment *a;
 +    unsigned long len = priv->num_pages * PAGE_SIZE;
 +
 +    mutex_lock(&priv->lock);
 +
 +    if (priv->vmap_cnt > 0)
 +        invalidate_kernel_vmap_range(priv->vaddr, len);
 +
 +    list_for_each_entry(a, &priv->attachments, head) {
 +        if (!a->mapped)
 +            continue;
 +
 +        dma_sync_sgtable_for_cpu(a->dev, &a->table, direction);
 +    }
 +
 +    mutex_unlock(&priv->lock);
 +
 +    return 0;
 +}
 +
 +static int
 +carveout_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf,
 +                     enum dma_data_direction direction)
 +{
 +    struct carveout_heap_buffer_priv *priv = dmabuf->priv;
 +    struct carveout_heap_attachment *a;
 +    unsigned long len = priv->num_pages * PAGE_SIZE;
 +
 +    mutex_lock(&priv->lock);
 +
 +    if (priv->vmap_cnt > 0)
 +        flush_kernel_vmap_range(priv->vaddr, len);
 +
 +    list_for_each_entry(a, &priv->attachments, head) {
 +        if (!a->mapped)
 +            continue;
 +
 +        dma_sync_sgtable_for_device(a->dev, &a->table, direction);
 +    }
 +
 +    mutex_unlock(&priv->lock);
 +
 +    return 0;
 +}
 +
 +static int carveout_heap_mmap(struct dma_buf *dmabuf,
 +                  struct vm_area_struct *vma)
 +{
 +    struct carveout_heap_buffer_priv *priv = dmabuf->priv;
 +    unsigned long len = priv->num_pages * PAGE_SIZE;
 +    struct page *page = virt_to_page(priv->vaddr);
 +
 +    return remap_pfn_range(vma, vma->vm_start, page_to_pfn(page),
 +                   len, vma->vm_page_prot);
 +}
 +
 +static int carveout_heap_vmap(struct dma_buf *dmabuf, struct iosys_map *map)
 +{
 +    struct carveout_heap_buffer_priv *priv = dmabuf->priv;
 +
 +    mutex_lock(&priv->lock);
 +
 +    iosys_map_set_vaddr(map, priv->vaddr);
 +    priv->vmap_cnt++;
 +
 +    mutex_unlock(&priv->lock);
 +
 +    return 0;
 +}
 +
 +static void carveout_heap_vunmap(struct dma_buf *dmabuf, struct iosys_map *map)
 +{
 +    struct carveout_heap_buffer_priv *priv = dmabuf->priv;
 +
 +    mutex_lock(&priv->lock);
 +
 +    priv->vmap_cnt--;
 +    mutex_unlock(&priv->lock);
 +
 +    iosys_map_clear(map);
 +}
 +
 +static void carveout_heap_dma_buf_release(struct dma_buf *buf)
 +{
 +    struct carveout_heap_buffer_priv *buffer_priv = buf->priv;
 +    struct carveout_heap_priv *heap_priv = buffer_priv->heap;
 +    unsigned long len = buffer_priv->num_pages * PAGE_SIZE;
 +
 +    gen_pool_free(heap_priv->pool, (unsigned long)buffer_priv->vaddr, len);
 +    kfree(buffer_priv);
 +}
 +
 +static const struct dma_buf_ops carveout_heap_buf_ops = {
 +    .attach        = carveout_heap_attach,
 +    .detach        = carveout_heap_detach,
 +    .map_dma_buf    = carveout_heap_map_dma_buf,
 +    .unmap_dma_buf    = carveout_heap_unmap_dma_buf,
 +    .begin_cpu_access    = carveout_heap_dma_buf_begin_cpu_access,
 +    .end_cpu_access    = carveout_heap_dma_buf_end_cpu_access,
 +    .mmap        = carveout_heap_mmap,
 +    .vmap        = carveout_heap_vmap,
 +    .vunmap        = carveout_heap_vunmap,
 +    .release    = carveout_heap_dma_buf_release,
 +};
 +
 +static struct dma_buf *carveout_heap_allocate(struct dma_heap *heap,
 +                          unsigned long len,
 +                          u32 fd_flags,
 +                          u64 heap_flags)
 +{
 +    struct carveout_heap_priv *heap_priv = dma_heap_get_drvdata(heap);
 +    struct carveout_heap_buffer_priv *buffer_priv;
 +    DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
 +    struct dma_buf *buf;
 +    dma_addr_t daddr;
 +    size_t size = PAGE_ALIGN(len);
 +    void *vaddr;
 +    int ret;
 +
 +    buffer_priv = kzalloc(sizeof(*buffer_priv), GFP_KERNEL);
 +    if (!buffer_priv)
 +        return ERR_PTR(-ENOMEM);
 +
 +    INIT_LIST_HEAD(&buffer_priv->attachments);
 +    mutex_init(&buffer_priv->lock);
 +
 +    vaddr = gen_pool_dma_zalloc(heap_priv->pool, size, &daddr);
 +    if (!vaddr) {
 +        ret = -ENOMEM;
 +        goto err_free_buffer_priv;
 +    }
 +
 +    buffer_priv->vaddr = vaddr;
 +    buffer_priv->daddr = daddr;
 +    buffer_priv->heap = heap_priv;
 +    buffer_priv->num_pages = size >> PAGE_SHIFT;
 +
 +    /* create the dmabuf */
 +    exp_info.exp_name = dma_heap_get_name(heap);
 +    exp_info.ops = &carveout_heap_buf_ops;
 +    exp_info.size = size;
 +    exp_info.flags = fd_flags;
 +    exp_info.priv = buffer_priv;
 +
 +    buf = dma_buf_export(&exp_info);
 +    if (IS_ERR(buf)) {
 +        ret = PTR_ERR(buf);
 +        goto err_free_buffer;
 +    }
 +
 +    return buf;
 +
 +err_free_buffer:
 +    gen_pool_free(heap_priv->pool, (unsigned long)vaddr, len);
 +err_free_buffer_priv:
 +    kfree(buffer_priv);
 +
 +    return ERR_PTR(ret);
 +}
 +
 +static const struct dma_heap_ops carveout_heap_ops = {
 +    .allocate = carveout_heap_allocate,
 +};
 +
 +static int __init carveout_heap_setup(struct device_node *node)
 +{
 +    struct dma_heap_export_info exp_info = {};
 +    const struct reserved_mem *rmem;
 +    struct carveout_heap_priv *priv;
 +    struct dma_heap *heap;
 +    struct gen_pool *pool;
 +    void *base;
 +    int ret;
 +
 +    rmem = of_reserved_mem_lookup(node);
 +    if (!rmem)
 +        return -EINVAL;
 +
 +    priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 +    if (!priv)
 +        return -ENOMEM;
 +
 +    pool = gen_pool_create(PAGE_SHIFT, NUMA_NO_NODE);
 +    if (!pool) {
 +        ret = -ENOMEM;
 +        goto err_cleanup_heap;
 +    }
 +    priv->pool = pool;
 +
 +    base = memremap(rmem->base, rmem->size, MEMREMAP_WB);
 +    if (!base) {
 +        ret = -ENOMEM;
 +        goto err_release_mem_region;
 +    }
 +
 +    ret = gen_pool_add_virt(pool, (unsigned long)base, rmem->base,
 +                rmem->size, NUMA_NO_NODE);
 +    if (ret)
 +        goto err_unmap;
 +
 +    exp_info.name = node->full_name;
 +    exp_info.ops = &carveout_heap_ops;
 +    exp_info.priv = priv;
 +
 +    heap = dma_heap_add(&exp_info);
 +    if (IS_ERR(heap)) {
 +        ret = PTR_ERR(heap);
 +        goto err_cleanup_pool_region;
 +    }
 +    priv->heap = heap;
 +
 +    return 0;
 +
 +err_cleanup_pool_region:
 +    gen_pool_free(pool, (unsigned long)base, rmem->size);
 +err_unmap:
 +    memunmap(base);
 +err_release_mem_region:
 +    gen_pool_destroy(pool);
 +err_cleanup_heap:
 +    kfree(priv);
 +    return ret;
 +}
 +
 +static int __init carveout_heap_init(void)
 +{
 +    struct device_node *rmem_node;
 +    struct device_node *node;
 +    int ret;
 +
 +    rmem_node = of_find_node_by_path("/reserved-memory");
 +    if (!rmem_node)
 +        return 0;
 +
 +    for_each_child_of_node(rmem_node, node) {
 +        if (!of_property_read_bool(node, "export"))
 +            continue;
 +
 +        ret = carveout_heap_setup(node);
 +        if (ret)
 +            return ret;
 +    }
 +
 +    return 0;
 +}
 +
 +module_init(carveout_heap_init);
 --
 .49.0

Hi,

This series is the follow-up of the discussion that John and I had some
time ago here:

https://lore.kernel.org/all/CANDhNCquJn6bH3KxKf65BWiTYLVqSd9892-xtFDHHqqyrroCMQ@mail.gmail.com/

The initial problem we were discussing was that I'm currently working on
a platform which has a memory layout with ECC enabled. However, enabling
the ECC has a number of drawbacks on that platform: lower performance,
increased memory usage, etc. So for things like framebuffers, the
trade-off isn't great and thus there's a memory region with ECC disabled
to allocate from for such use cases.

After a suggestion from John, I chose to first start using heap
allocations flags to allow for userspace to ask for a particular ECC
setup. This is then backed by a new heap type that runs from reserved
memory chunks flagged as such, and the existing DT properties to specify
the ECC properties.

After further discussion, it was considered that flags were not the
right solution, and relying on the names of the heaps would be enough to
let userspace know the kind of buffer it deals with.

Thus, even though the uAPI part of it has been dropped in this second
version, we still need a driver to create heaps out of carved-out memory
regions. In addition to the original usecase, a similar driver can be
found in BSPs from most vendors, so I believe it would be a useful
addition to the kernel.

I submitted a draft PR to the DT schema for the bindings used in this
PR:
https://github.com/devicetree-org/dt-schema/pull/138

Let me know what you think,
Maxime

Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
Changes in v2:
- Add vmap/vunmap operations
- Drop ECC flags uapi
- Rebase on top of 6.14
- Link to v1: https://lore.kernel.org/r/20240515-dma-buf-ecc-heap-v1-0-54cbbd049511@kernel.org

---
Maxime Ripard (2):
      dma-buf: heaps: system: Remove global variable
      dma-buf: heaps: Introduce a new heap for reserved memory

drivers/dma-buf/heaps/Kconfig         |   8 +
 drivers/dma-buf/heaps/Makefile        |   1 +
 drivers/dma-buf/heaps/carveout_heap.c | 360 ++++++++++++++++++++++++++++++++++
 drivers/dma-buf/heaps/system_heap.c   |  17 +-
 4 files changed, 381 insertions(+), 5 deletions(-)
---
base-commit: fcbf30774e82a441890b722bf0c26542fb82150f
change-id: 20240515-dma-buf-ecc-heap-28a311d2c94e

Best regards,
-- 
Maxime Ripard <mripard@kernel.org>

The system heap has been using its struct dma_heap pointer but wasn't
using it anywhere.

Since we'll need additional parameters to attach to that heap type,
let's create a private structure and set it as the dma_heap drvdata,
removing the global variable in the process.

Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
 drivers/dma-buf/heaps/system_heap.c | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/drivers/dma-buf/heaps/system_heap.c b/drivers/dma-buf/heaps/system_heap.c
index XXXXXXX..XXXXXXX 100644
--- a/drivers/dma-buf/heaps/system_heap.c
+++ b/drivers/dma-buf/heaps/system_heap.c
@@ -XXX,XX +XXX,XX @@
 #include <linux/module.h>
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 
-static struct dma_heap *sys_heap;
+struct system_heap {
+	struct dma_heap *heap;
+};
 
 struct system_heap_buffer {
 	struct dma_heap *heap;
 	struct list_head attachments;
 	struct mutex lock;
@@ -XXX,XX +XXX,XX @@ static const struct dma_heap_ops system_heap_ops = {
 };
 
 static int __init system_heap_create(void)
 {
 	struct dma_heap_export_info exp_info;
+	struct system_heap *sys_heap;
+
+	sys_heap = kzalloc(sizeof(*sys_heap), GFP_KERNEL);
+	if (!sys_heap)
+		return -ENOMEM;
 
 	exp_info.name = "system";
 	exp_info.ops = &system_heap_ops;
-	exp_info.priv = NULL;
+	exp_info.priv = sys_heap;
 
-	sys_heap = dma_heap_add(&exp_info);
-	if (IS_ERR(sys_heap))
-		return PTR_ERR(sys_heap);
+	sys_heap->heap = dma_heap_add(&exp_info);
+	if (IS_ERR(sys_heap->heap))
+		return PTR_ERR(sys_heap->heap);
 
 	return 0;
 }
 module_init(system_heap_create);

-- 
2.49.0

Some reserved memory regions might have particular memory setup or
attributes that make them good candidates for heaps.

Let's provide a heap type that will create a new heap for each reserved
memory region flagged as such.

Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
 drivers/dma-buf/heaps/Kconfig         |   8 +
 drivers/dma-buf/heaps/Makefile        |   1 +
 drivers/dma-buf/heaps/carveout_heap.c | 360 ++++++++++++++++++++++++++++++++++
 3 files changed, 369 insertions(+)

diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig
index XXXXXXX..XXXXXXX 100644
--- a/drivers/dma-buf/heaps/Kconfig
+++ b/drivers/dma-buf/heaps/Kconfig
@@ -XXX,XX +XXX,XX @@
+config DMABUF_HEAPS_CARVEOUT
+	bool "Carveout Heaps"
+	depends on DMABUF_HEAPS
+	help
+	  Choose this option to enable the carveout dmabuf heap. The carveout
+	  heap is backed by pages from reserved memory regions flagged as
+	  exportable. If in doubt, say Y.
+
 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
diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile
index XXXXXXX..XXXXXXX 100644
--- a/drivers/dma-buf/heaps/Makefile
+++ b/drivers/dma-buf/heaps/Makefile
@@ -XXX,XX +XXX,XX @@
 # SPDX-License-Identifier: GPL-2.0
+obj-$(CONFIG_DMABUF_HEAPS_CARVEOUT)	+= carveout_heap.o
 obj-$(CONFIG_DMABUF_HEAPS_SYSTEM)	+= system_heap.o
 obj-$(CONFIG_DMABUF_HEAPS_CMA)		+= cma_heap.o
diff --git a/drivers/dma-buf/heaps/carveout_heap.c b/drivers/dma-buf/heaps/carveout_heap.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/drivers/dma-buf/heaps/carveout_heap.c
@@ -XXX,XX +XXX,XX @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/dma-buf.h>
+#include <linux/dma-heap.h>
+#include <linux/genalloc.h>
+#include <linux/highmem.h>
+#include <linux/of_reserved_mem.h>
+
+struct carveout_heap_priv {
+	struct dma_heap *heap;
+	struct gen_pool *pool;
+};
+
+struct carveout_heap_buffer_priv {
+	struct mutex lock;
+	struct list_head attachments;
+
+	unsigned long num_pages;
+	struct carveout_heap_priv *heap;
+	dma_addr_t daddr;
+	void *vaddr;
+	unsigned int vmap_cnt;
+};
+
+struct carveout_heap_attachment {
+	struct list_head head;
+	struct sg_table table;
+
+	struct device *dev;
+	bool mapped;
+};
+
+static int carveout_heap_attach(struct dma_buf *buf,
+				struct dma_buf_attachment *attachment)
+{
+	struct carveout_heap_buffer_priv *priv = buf->priv;
+	struct carveout_heap_attachment *a;
+	struct sg_table *sgt;
+	unsigned long len = priv->num_pages * PAGE_SIZE;
+	int ret;
+
+	a = kzalloc(sizeof(*a), GFP_KERNEL);
+	if (!a)
+		return -ENOMEM;
+	INIT_LIST_HEAD(&a->head);
+	a->dev = attachment->dev;
+	attachment->priv = a;
+
+	sgt = &a->table;
+	ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
+	if (ret)
+		goto err_cleanup_attach;
+
+	sg_dma_address(sgt->sgl) = priv->daddr;
+	sg_dma_len(sgt->sgl) = len;
+
+	mutex_lock(&priv->lock);
+	list_add(&a->head, &priv->attachments);
+	mutex_unlock(&priv->lock);
+
+	return 0;
+
+err_cleanup_attach:
+	kfree(a);
+	return ret;
+}
+
+static void carveout_heap_detach(struct dma_buf *dmabuf,
+				 struct dma_buf_attachment *attachment)
+{
+	struct carveout_heap_buffer_priv *priv = dmabuf->priv;
+	struct carveout_heap_attachment *a = attachment->priv;
+
+	mutex_lock(&priv->lock);
+	list_del(&a->head);
+	mutex_unlock(&priv->lock);
+
+	sg_free_table(&a->table);
+	kfree(a);
+}
+
+static struct sg_table *
+carveout_heap_map_dma_buf(struct dma_buf_attachment *attachment,
+			  enum dma_data_direction direction)
+{
+	struct carveout_heap_attachment *a = attachment->priv;
+	struct sg_table *table = &a->table;
+	int ret;
+
+	ret = dma_map_sgtable(a->dev, table, direction, 0);
+	if (ret)
+		return ERR_PTR(-ENOMEM);
+
+	a->mapped = true;
+
+	return table;
+}
+
+static void carveout_heap_unmap_dma_buf(struct dma_buf_attachment *attachment,
+					struct sg_table *table,
+					enum dma_data_direction direction)
+{
+	struct carveout_heap_attachment *a = attachment->priv;
+
+	a->mapped = false;
+	dma_unmap_sgtable(a->dev, table, direction, 0);
+}
+
+static int
+carveout_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
+				       enum dma_data_direction direction)
+{
+	struct carveout_heap_buffer_priv *priv = dmabuf->priv;
+	struct carveout_heap_attachment *a;
+	unsigned long len = priv->num_pages * PAGE_SIZE;
+
+	mutex_lock(&priv->lock);
+
+	if (priv->vmap_cnt > 0)
+		invalidate_kernel_vmap_range(priv->vaddr, len);
+
+	list_for_each_entry(a, &priv->attachments, head) {
+		if (!a->mapped)
+			continue;
+
+		dma_sync_sgtable_for_cpu(a->dev, &a->table, direction);
+	}
+
+	mutex_unlock(&priv->lock);
+
+	return 0;
+}
+
+static int
+carveout_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf,
+				     enum dma_data_direction direction)
+{
+	struct carveout_heap_buffer_priv *priv = dmabuf->priv;
+	struct carveout_heap_attachment *a;
+	unsigned long len = priv->num_pages * PAGE_SIZE;
+
+	mutex_lock(&priv->lock);
+
+	if (priv->vmap_cnt > 0)
+		flush_kernel_vmap_range(priv->vaddr, len);
+
+	list_for_each_entry(a, &priv->attachments, head) {
+		if (!a->mapped)
+			continue;
+
+		dma_sync_sgtable_for_device(a->dev, &a->table, direction);
+	}
+
+	mutex_unlock(&priv->lock);
+
+	return 0;
+}
+
+static int carveout_heap_mmap(struct dma_buf *dmabuf,
+			      struct vm_area_struct *vma)
+{
+	struct carveout_heap_buffer_priv *priv = dmabuf->priv;
+	unsigned long len = priv->num_pages * PAGE_SIZE;
+	struct page *page = virt_to_page(priv->vaddr);
+
+	return remap_pfn_range(vma, vma->vm_start, page_to_pfn(page),
+			       len, vma->vm_page_prot);
+}
+
+static int carveout_heap_vmap(struct dma_buf *dmabuf, struct iosys_map *map)
+{
+	struct carveout_heap_buffer_priv *priv = dmabuf->priv;
+
+	mutex_lock(&priv->lock);
+
+	iosys_map_set_vaddr(map, priv->vaddr);
+	priv->vmap_cnt++;
+
+	mutex_unlock(&priv->lock);
+
+	return 0;
+}
+
+static void carveout_heap_vunmap(struct dma_buf *dmabuf, struct iosys_map *map)
+{
+	struct carveout_heap_buffer_priv *priv = dmabuf->priv;
+
+	mutex_lock(&priv->lock);
+
+	priv->vmap_cnt--;
+	mutex_unlock(&priv->lock);
+
+	iosys_map_clear(map);
+}
+
+static void carveout_heap_dma_buf_release(struct dma_buf *buf)
+{
+	struct carveout_heap_buffer_priv *buffer_priv = buf->priv;
+	struct carveout_heap_priv *heap_priv = buffer_priv->heap;
+	unsigned long len = buffer_priv->num_pages * PAGE_SIZE;
+
+	gen_pool_free(heap_priv->pool, (unsigned long)buffer_priv->vaddr, len);
+	kfree(buffer_priv);
+}
+
+static const struct dma_buf_ops carveout_heap_buf_ops = {
+	.attach		= carveout_heap_attach,
+	.detach		= carveout_heap_detach,
+	.map_dma_buf	= carveout_heap_map_dma_buf,
+	.unmap_dma_buf	= carveout_heap_unmap_dma_buf,
+	.begin_cpu_access	= carveout_heap_dma_buf_begin_cpu_access,
+	.end_cpu_access	= carveout_heap_dma_buf_end_cpu_access,
+	.mmap		= carveout_heap_mmap,
+	.vmap		= carveout_heap_vmap,
+	.vunmap		= carveout_heap_vunmap,
+	.release	= carveout_heap_dma_buf_release,
+};
+
+static struct dma_buf *carveout_heap_allocate(struct dma_heap *heap,
+					      unsigned long len,
+					      u32 fd_flags,
+					      u64 heap_flags)
+{
+	struct carveout_heap_priv *heap_priv = dma_heap_get_drvdata(heap);
+	struct carveout_heap_buffer_priv *buffer_priv;
+	DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
+	struct dma_buf *buf;
+	dma_addr_t daddr;
+	size_t size = PAGE_ALIGN(len);
+	void *vaddr;
+	int ret;
+
+	buffer_priv = kzalloc(sizeof(*buffer_priv), GFP_KERNEL);
+	if (!buffer_priv)
+		return ERR_PTR(-ENOMEM);
+
+	INIT_LIST_HEAD(&buffer_priv->attachments);
+	mutex_init(&buffer_priv->lock);
+
+	vaddr = gen_pool_dma_zalloc(heap_priv->pool, size, &daddr);
+	if (!vaddr) {
+		ret = -ENOMEM;
+		goto err_free_buffer_priv;
+	}
+
+	buffer_priv->vaddr = vaddr;
+	buffer_priv->daddr = daddr;
+	buffer_priv->heap = heap_priv;
+	buffer_priv->num_pages = size >> PAGE_SHIFT;
+
+	/* create the dmabuf */
+	exp_info.exp_name = dma_heap_get_name(heap);
+	exp_info.ops = &carveout_heap_buf_ops;
+	exp_info.size = size;
+	exp_info.flags = fd_flags;
+	exp_info.priv = buffer_priv;
+
+	buf = dma_buf_export(&exp_info);
+	if (IS_ERR(buf)) {
+		ret = PTR_ERR(buf);
+		goto err_free_buffer;
+	}
+
+	return buf;
+
+err_free_buffer:
+	gen_pool_free(heap_priv->pool, (unsigned long)vaddr, len);
+err_free_buffer_priv:
+	kfree(buffer_priv);
+
+	return ERR_PTR(ret);
+}
+
+static const struct dma_heap_ops carveout_heap_ops = {
+	.allocate = carveout_heap_allocate,
+};
+
+static int __init carveout_heap_setup(struct device_node *node)
+{
+	struct dma_heap_export_info exp_info = {};
+	const struct reserved_mem *rmem;
+	struct carveout_heap_priv *priv;
+	struct dma_heap *heap;
+	struct gen_pool *pool;
+	void *base;
+	int ret;
+
+	rmem = of_reserved_mem_lookup(node);
+	if (!rmem)
+		return -EINVAL;
+
+	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	if (!priv)
+		return -ENOMEM;
+
+	pool = gen_pool_create(PAGE_SHIFT, NUMA_NO_NODE);
+	if (!pool) {
+		ret = -ENOMEM;
+		goto err_cleanup_heap;
+	}
+	priv->pool = pool;
+
+	base = memremap(rmem->base, rmem->size, MEMREMAP_WB);
+	if (!base) {
+		ret = -ENOMEM;
+		goto err_release_mem_region;
+	}
+
+	ret = gen_pool_add_virt(pool, (unsigned long)base, rmem->base,
+				rmem->size, NUMA_NO_NODE);
+	if (ret)
+		goto err_unmap;
+
+	exp_info.name = node->full_name;
+	exp_info.ops = &carveout_heap_ops;
+	exp_info.priv = priv;
+
+	heap = dma_heap_add(&exp_info);
+	if (IS_ERR(heap)) {
+		ret = PTR_ERR(heap);
+		goto err_cleanup_pool_region;
+	}
+	priv->heap = heap;
+
+	return 0;
+
+err_cleanup_pool_region:
+	gen_pool_free(pool, (unsigned long)base, rmem->size);
+err_unmap:
+	memunmap(base);
+err_release_mem_region:
+	gen_pool_destroy(pool);
+err_cleanup_heap:
+	kfree(priv);
+	return ret;
+}
+
+static int __init carveout_heap_init(void)
+{
+	struct device_node *rmem_node;
+	struct device_node *node;
+	int ret;
+
+	rmem_node = of_find_node_by_path("/reserved-memory");
+	if (!rmem_node)
+		return 0;
+
+	for_each_child_of_node(rmem_node, node) {
+		if (!of_property_read_bool(node, "export"))
+			continue;
+
+		ret = carveout_heap_setup(node);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+module_init(carveout_heap_init);

-- 
2.49.0

Hi,

This series is the follow-up of the discussion that John and I had some
time ago here:

https://lore.kernel.org/all/CANDhNCquJn6bH3KxKf65BWiTYLVqSd9892-xtFDHHqqyrroCMQ@mail.gmail.com/

After further discussion, it was considered that flags were not the
right solution, and relying on the names of the heaps would be enough to
let userspace know the kind of buffer it deals with.

I submitted a draft PR to the DT schema for the bindings used in this
PR:
https://github.com/devicetree-org/dt-schema/pull/138

Let me know what you think,
Maxime

Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
Changes in v3:
- Reworked global variable patch
- Link to v2: https://lore.kernel.org/r/20250401-dma-buf-ecc-heap-v2-0-043fd006a1af@kernel.org

Changes in v2:
- Add vmap/vunmap operations
- Drop ECC flags uapi
- Rebase on top of 6.14
- Link to v1: https://lore.kernel.org/r/20240515-dma-buf-ecc-heap-v1-0-54cbbd049511@kernel.org

---
Maxime Ripard (2):
      dma-buf: heaps: system: Remove global variable
      dma-buf: heaps: Introduce a new heap for reserved memory

drivers/dma-buf/heaps/Kconfig         |   8 +
 drivers/dma-buf/heaps/Makefile        |   1 +
 drivers/dma-buf/heaps/carveout_heap.c | 360 ++++++++++++++++++++++++++++++++++
 drivers/dma-buf/heaps/system_heap.c   |   3 +-
 4 files changed, 370 insertions(+), 2 deletions(-)
---
base-commit: fcbf30774e82a441890b722bf0c26542fb82150f
change-id: 20240515-dma-buf-ecc-heap-28a311d2c94e

Best regards,
-- 
Maxime Ripard <mripard@kernel.org>

The system heap is storing its struct dma_heap pointer in a global
variable but isn't using it anywhere.

Let's move the global variable into system_heap_create() to make it
local.

Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
 drivers/dma-buf/heaps/system_heap.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

-- 
2.49.0

Some reserved memory regions might have particular memory setup or
attributes that make them good candidates for heaps.

Let's provide a heap type that will create a new heap for each reserved
memory region flagged as such.

-- 
2.49.0