Claude review: dma-buf: heaps: Turn heaps into modules

Claude review: dma-buf: heaps: Turn heaps into modules

[Claude Code Review Bot]

Overall Series Review

Subject: dma-buf: heaps: Turn heaps into modules
Author: Maxime Ripard <mripard@kernel.org>
Patches: 22
Reviewed: 2026-02-27T13:12:02.708329

---

This series by Maxime Ripard converts the CMA and system dma-buf heaps from built-in-only to tristate (module-capable) Kconfig symbols. The approach is straightforward: (1) reverse the dependency so the kernel core stores reserved CMA regions and the heap module iterates over them, (2) export the necessary CMA and dma-buf symbols, and (3) add the standard `MODULE_*` macros.

The series is generally well-structured and the design decision to invert the registration flow (kernel stores CMA regions, heap module queries them) is sound and cleanly resolves the built-in-to-module dependency.

There are a few issues worth raising, most notably: neither heap has a `module_exit` function, and the `__init` annotations on the CMA heap functions are fine for built-in but become effectively no-ops for modules (which is safe but worth a note). One ordering concern exists with `rmem_cma_areas` not being `__initdata` while the old `dma_areas` was.

---
Generated by Claude Code Patch Reviewer

Claude review: dma-buf: heaps: Turn heaps into modules

[Claude Code Review Bot]

Overall Series Review

Subject: dma-buf: heaps: Turn heaps into modules
Author: Maxime Ripard <mripard@kernel.org>
Patches: 9
Reviewed: 2026-03-04T07:41:35.266050

---

**Author**: Maxime Ripard <mripard@kernel.org>
**Series**: dma-buf: heaps: Turn heaps into modules (v3, 8 patches)

This series enables the CMA and system dma-buf heaps to be compiled as loadable modules (tristate). The approach is well-structured: patches 1-6 prepare the prerequisites (inverting the CMA registration logic, exporting necessary symbols), and patches 7-8 make the actual `bool` → `tristate` Kconfig changes.

The overall design is sound. Inverting the registration so the heap queries the contiguous DMA code (rather than the contiguous code calling into the heap) is the right way to break the built-in → module dependency. The patches are generally well-separated with clear commit messages.

**However, there is a build-breaking bug:** patch 1 removes the `dma_heap_cma_register_heap()` function definition from `cma_heap.c`, but the call site at `kernel/dma/contiguous.c:276` and the header declaration in `include/linux/dma-buf/heaps/cma.h` are left behind. This causes a **link error** when `CONFIG_DMABUF_HEAPS_CMA=y`. Details below.

---

---
Generated by Claude Code Patch Reviewer

Claude review: dma-buf: heaps: Turn heaps into modules

[Claude Code Review Bot]

Overall Series Review

Subject: dma-buf: heaps: Turn heaps into modules
Author: Maxime Ripard <mripard@kernel.org>
Patches: 10
Reviewed: 2026-04-01T07:50:36.145257

---

This is a well-structured series by Maxime Ripard (v4) that enables the CMA and system dma-buf heaps to be built as loadable modules. The approach is sound: invert the dependency so that `kernel/dma/contiguous.c` stores the CMA areas and provides an iterator, rather than calling into the heap code. The series is logically ordered, with each patch building on the previous one, and the individual changes are small and easy to follow.

The key concern is around **duplicate registration of the default CMA area**, which I detail below. Otherwise, the series looks good and the progression from inverting the logic, to de-inlining, to making static, to exporting, and finally to tristate is clean.

One note from the mbox: patches 3 and 4 appear in the mbox in the **wrong order** relative to the cover letter (the mbox has patch 3 "Make dma_contiguous_default_area static" before patch 4 "Export dev_get_cma_area()", but the message numbering is correct). The logical dependency is fine either way since patch 3 makes the variable static and patch 4 exports the function, and they touch independent lines.

---
Generated by Claude Code Patch Reviewer

[PATCH v5 0/4] dma-buf: heaps: Turn heaps into modules

[Maxime Ripard]

Hi,

The recent introduction of heaps in the optee driver [1] made possible
the creation of heaps as modules.

It's generally a good idea if possible, including for the already
existing system and CMA heaps.

The system one is pretty trivial, the CMA is now easy too with the
reworks we got in 7.1-r1.

Let me know what you think,
Maxime

1: https://lore.kernel.org/dri-devel/20250911135007.1275833-4-jens.wiklander@linaro.org/

Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
Changes in v5:
- Rebase on 7.1-rc1
- Add a patch to enable the heaps in arm64 defconfig
- Link to v4: https://lore.kernel.org/r/20260331-dma-buf-heaps-as-modules-v4-0-e18fda504419@kernel.org

Changes in v4:
- Fix compilation failure
- Rework to take into account OF_RESERVED_MEM
- Fix regression making the default CMA area disappear if not created
  through the DT
- Added some documentation and comments
- Link to v3: https://lore.kernel.org/r/20260303-dma-buf-heaps-as-modules-v3-0-24344812c707@kernel.org

Changes in v3:
- Squashed cma_get_name and cma_alloc/release patches
- Fixed typo in Export dev_get_cma_area commit title
- Fixed compilation failure with DMA_CMA but not OF_RESERVED_MEM
- Link to v2: https://lore.kernel.org/r/20260227-dma-buf-heaps-as-modules-v2-0-454aee7e06cc@kernel.org

Changes in v2:
- Collect tags
- Don't export dma_contiguous_default_area anymore, but export
  dev_get_cma_area instead
- Mentioned that heap modules can't be removed
- Link to v1: https://lore.kernel.org/r/20260225-dma-buf-heaps-as-modules-v1-0-2109225a090d@kernel.org

---
Maxime Ripard (4):
      dma-buf: heaps: Export mem_accounting parameter
      dma-buf: heaps: cma: Turn the heap into a module
      dma-buf: heaps: system: Turn the heap into a module
      arm64: defconfig: Enable dma-buf heaps

 arch/arm64/configs/defconfig        | 3 +++
 drivers/dma-buf/dma-heap.c          | 1 +
 drivers/dma-buf/heaps/Kconfig       | 4 ++--
 drivers/dma-buf/heaps/cma_heap.c    | 3 +++
 drivers/dma-buf/heaps/system_heap.c | 5 +++++
 5 files changed, 14 insertions(+), 2 deletions(-)
---
base-commit: 5e9b7d093f3f77cb0af4409559e3d139babfb443
change-id: 20260225-dma-buf-heaps-as-modules-1034b3ec9f2a

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

[PATCH v5 1/4] dma-buf: heaps: Export mem_accounting parameter

[Maxime Ripard]

The mem_accounting kernel parameter is used by heaps to know if they
should account allocations in their respective cgroup controllers.

Since we're going to allow heaps to compile as modules, we need to
export that variable.

Reviewed-by: T.J. Mercier <tjmercier@google.com>
Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
 drivers/dma-buf/dma-heap.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/dma-buf/dma-heap.c b/drivers/dma-buf/dma-heap.c
index ac5f8685a649..a76bf3f8b071 100644
--- a/drivers/dma-buf/dma-heap.c
+++ b/drivers/dma-buf/dma-heap.c
@@ -51,10 +51,11 @@ static DEFINE_XARRAY_ALLOC(dma_heap_minors);
 
 bool __read_mostly mem_accounting;
 module_param(mem_accounting, bool, 0444);
 MODULE_PARM_DESC(mem_accounting,
 		 "Enable cgroup-based memory accounting for dma-buf heap allocations (default=false).");
+EXPORT_SYMBOL_NS_GPL(mem_accounting, "DMA_BUF_HEAP");
 
 static int dma_heap_buffer_alloc(struct dma_heap *heap, size_t len,
 				 u32 fd_flags,
 				 u64 heap_flags)
 {

-- 
2.53.0

[PATCH v5 2/4] dma-buf: heaps: cma: Turn the heap into a module

[Maxime Ripard]

All the symbols used by the CMA heap are already exported, so turning it
into a module is straightforward. We only need to add the usual MODULE_*
macros, import the proper namespaces and change the Kconfig symbol to a
tristate.

This heap won't be able to unload though, since we're missing a lot of
infrastructure to make it safe.

Reviewed-by: T.J. Mercier <tjmercier@google.com>
Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
 drivers/dma-buf/heaps/Kconfig    | 2 +-
 drivers/dma-buf/heaps/cma_heap.c | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig
index a5eef06c4226..aed0b9b4febf 100644
--- a/drivers/dma-buf/heaps/Kconfig
+++ b/drivers/dma-buf/heaps/Kconfig
@@ -4,11 +4,11 @@ config DMABUF_HEAPS_SYSTEM
 	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.
 
 config DMABUF_HEAPS_CMA
-	bool "DMA-BUF CMA Heap"
+	tristate "DMA-BUF CMA Heap"
 	depends on DMABUF_HEAPS && DMA_CMA
 	help
 	  Choose this option to enable dma-buf CMA heap. This heap is backed
 	  by the Contiguous Memory Allocator (CMA). If your system has these
 	  regions, you should say Y here.
diff --git a/drivers/dma-buf/heaps/cma_heap.c b/drivers/dma-buf/heaps/cma_heap.c
index a359aac45579..3fb4b946c91a 100644
--- a/drivers/dma-buf/heaps/cma_heap.c
+++ b/drivers/dma-buf/heaps/cma_heap.c
@@ -418,5 +418,8 @@ static int __init add_cma_heaps(void)
 
 	return 0;
 }
 module_init(add_cma_heaps);
 MODULE_DESCRIPTION("DMA-BUF CMA Heap");
+MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS("DMA_BUF");
+MODULE_IMPORT_NS("DMA_BUF_HEAP");

-- 
2.53.0

[PATCH v5 3/4] dma-buf: heaps: system: Turn the heap into a module

[Maxime Ripard]

The system heap can be easily turned into a module by adding the usual
MODULE_* macros, importing the proper namespaces and changing the
Kconfig symbol to a tristate.

This heap won't be able to unload though, since we're missing a lot of
infrastructure to make it safe.

Reviewed-by: T.J. Mercier <tjmercier@google.com>
Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
 drivers/dma-buf/heaps/Kconfig       | 2 +-
 drivers/dma-buf/heaps/system_heap.c | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig
index aed0b9b4febf..e273fb18feca 100644
--- a/drivers/dma-buf/heaps/Kconfig
+++ b/drivers/dma-buf/heaps/Kconfig
@@ -1,7 +1,7 @@
 config DMABUF_HEAPS_SYSTEM
-	bool "DMA-BUF System Heap"
+	tristate "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/system_heap.c b/drivers/dma-buf/heaps/system_heap.c
index 03c2b87cb111..c92bdec356fc 100644
--- a/drivers/dma-buf/heaps/system_heap.c
+++ b/drivers/dma-buf/heaps/system_heap.c
@@ -535,5 +535,10 @@ static int __init system_heap_create(void)
 		return PTR_ERR(sys_heap);
 
 	return 0;
 }
 module_init(system_heap_create);
+
+MODULE_DESCRIPTION("DMA-BUF System Heap");
+MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS("DMA_BUF");
+MODULE_IMPORT_NS("DMA_BUF_HEAP");

-- 
2.53.0

[PATCH v5 4/4] arm64: defconfig: Enable dma-buf heaps

[Maxime Ripard]

Now that the system and CMA heaps can be built as modules, enable both
as modules in the arm64 defconfig.

Signed-off-by: Maxime Ripard <mripard@kernel.org>
---
 arch/arm64/configs/defconfig | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig
index d905a0777f93..f33193b50e6b 100644
--- a/arch/arm64/configs/defconfig
+++ b/arch/arm64/configs/defconfig
@@ -1409,10 +1409,13 @@ CONFIG_RCAR_DMAC=y
 CONFIG_RENESAS_USB_DMAC=m
 CONFIG_RZ_DMAC=y
 CONFIG_TI_K3_UDMA=y
 CONFIG_TI_K3_UDMA_GLUE_LAYER=y
 CONFIG_STM32_DMA3=m
+CONFIG_DMABUF_HEAPS=y
+CONFIG_DMABUF_HEAPS_SYSTEM=m
+CONFIG_DMABUF_HEAPS_CMA=m
 CONFIG_VFIO=y
 CONFIG_VFIO_PCI=y
 CONFIG_VIRTIO_PCI=y
 CONFIG_VIRTIO_BALLOON=y
 CONFIG_VIRTIO_MMIO=y

-- 
2.53.0

Claude review: dma-buf: heaps: Turn heaps into modules

[Claude Code Review Bot]

Overall Series Review

Subject: dma-buf: heaps: Turn heaps into modules
Author: Maxime Ripard <mripard@kernel.org>
Patches: 5
Reviewed: 2026-04-28T14:45:00.914337

---

This is a clean, well-scoped 4-patch series from Maxime Ripard that converts the DMA-BUF CMA and system heaps from `bool` Kconfig options to `tristate`, allowing them to be built as loadable modules. The series is straightforward: patch 1 exports the one remaining unexported symbol (`mem_accounting`), patches 2-3 add the MODULE_* macros and change the Kconfig type for each heap, and patch 4 enables both as `=m` in the arm64 defconfig.

The series is at v5 and already carries `Reviewed-by: T.J. Mercier` on patches 1-3. The changes are minimal, correct, and well-ordered. No significant issues found.

**Verdict: Looks good to merge.**

One minor observation below, but nothing blocking.

---

---
Generated by Claude Code Patch Reviewer

Claude review: dma-buf: heaps: Export mem_accounting parameter

[Claude Code Review Bot]

Patch Review

**Change:** Adds `EXPORT_SYMBOL_NS_GPL(mem_accounting, "DMA_BUF_HEAP")` after the existing `module_param` declaration in `drivers/dma-buf/dma-heap.c`.

This is correct and necessary. The `mem_accounting` variable is declared `extern` in `include/linux/dma-heap.h:49` and is used by `system_heap.c:388`. Without this export, building `system_heap.c` as a module would fail at link time. Using `_NS_GPL` with the `"DMA_BUF_HEAP"` namespace is consistent with the existing export namespace for the dma-buf heap APIs.

Note that `cma_heap.c` does not currently reference `mem_accounting`, so this export is strictly needed only for the system heap (patch 3), not the CMA heap (patch 2). The ordering is still correct since patch 1 logically prepares the infrastructure for both module conversions.

No issues.

---
Generated by Claude Code Patch Reviewer

Claude review: dma-buf: heaps: cma: Turn the heap into a module

[Claude Code Review Bot]

Patch Review

**Change:** 
- `drivers/dma-buf/heaps/Kconfig`: `DMABUF_HEAPS_CMA` changed from `bool` to `tristate`
- `drivers/dma-buf/heaps/cma_heap.c`: Adds `MODULE_LICENSE("GPL")`, `MODULE_IMPORT_NS("DMA_BUF")`, `MODULE_IMPORT_NS("DMA_BUF_HEAP")`

The commit message correctly notes this heap can't be unloaded since there is no `module_exit` function — confirmed by grep showing no `module_exit` in any heap source. This is a deliberate design choice; the kernel will simply refuse to unload the module. The cover letter and v2 changelog mention this was documented.

The two `MODULE_IMPORT_NS` lines match the namespaces used by `dma_heap_add()` (exported in `"DMA_BUF"`) and `mem_accounting` (exported in `"DMA_BUF_HEAP"`). Even though `cma_heap.c` doesn't directly use `mem_accounting`, importing `DMA_BUF_HEAP` is fine as the CMA heap uses other `DMA_BUF_HEAP`-namespaced symbols.

No issues.

---
Generated by Claude Code Patch Reviewer

Claude review: dma-buf: heaps: system: Turn the heap into a module

[Claude Code Review Bot]

Patch Review

**Change:**
- `drivers/dma-buf/heaps/Kconfig`: `DMABUF_HEAPS_SYSTEM` changed from `bool` to `tristate`
- `drivers/dma-buf/heaps/system_heap.c`: Adds `MODULE_DESCRIPTION("DMA-BUF System Heap")`, `MODULE_LICENSE("GPL")`, `MODULE_IMPORT_NS("DMA_BUF")`, `MODULE_IMPORT_NS("DMA_BUF_HEAP")`

Same pattern as the CMA heap patch. This one also adds `MODULE_DESCRIPTION` which the CMA heap already had from a prior commit. The namespace imports are correct — this heap directly uses `mem_accounting` (at line 388), so the `DMA_BUF_HEAP` import is needed.

Same no-`module_exit` situation applies here, correctly documented.

No issues.

---
Generated by Claude Code Patch Reviewer

Claude review: arm64: defconfig: Enable dma-buf heaps

[Claude Code Review Bot]

Patch Review

**Change:** Adds three lines to `arch/arm64/configs/defconfig`:
```
CONFIG_DMABUF_HEAPS=y
CONFIG_DMABUF_HEAPS_SYSTEM=m
CONFIG_DMABUF_HEAPS_CMA=m
```

The placement is between `CONFIG_STM32_DMA3=m` and `CONFIG_VFIO=y` (confirmed at lines 1413-1417 in the applied tree). The base framework (`DMABUF_HEAPS`) is `=y` which is required since the heaps depend on it and it's a `bool`. Both heaps are `=m` which exercises the new tristate functionality.

**Minor observation:** The defconfig insertion point is in the DMA engine section (between STM32_DMA3 and VFIO). This is arguably fine since defconfigs aren't strictly section-organized by subsystem, but one could argue these belong near other dmabuf/graphics config entries. This is purely cosmetic and not worth blocking on.

No issues.

---
Generated by Claude Code Patch Reviewer