[PATCH v3 08/11] nvmem: disconnect cells before removing their layout

From: James Hilliard

Date: Fri Nov 20 2026 - 15:09:40 EST


A layout can be unbound while NVMEM consumers retain its cells. Keeping
the layout module loaded does not retain its binding or private data,
and looking up the module again at cell put can access a removed layout.

A failed add_cells callback can also leave cells registered even though
the layout never bound. The sysfs failure path instead removes every
cell, including cells supplied by the provider.

Remove the layout-owned cells from lookup and mark them disconnected.
Drain their sysfs attributes and SRCU-protected accesses before returning
to the layout driver. Old handles retain only cell metadata and reject
I/O; a later layout probe creates new cells. Use the same cleanup when
cell registration or sysfs population fails.

Replace the layout module get/put paths with this drain. Leave provider
cells registered and rebuild their attributes after layout removal.
Clear the provider-to-layout link when the layout device is unregistered.

Fixes: fc29fd821d9a ("nvmem: core: Rework layouts to become regular devices")
Signed-off-by: James Hilliard <james.hilliard1@xxxxxxxxx>
---
drivers/nvmem/core.c | 78 +++++++++++++++++++++++--------------------------
drivers/nvmem/layouts.c | 2 ++
2 files changed, 38 insertions(+), 42 deletions(-)

diff --git a/drivers/nvmem/core.c b/drivers/nvmem/core.c
index 49e80389e198..edc2f61e6e0a 100644
--- a/drivers/nvmem/core.c
+++ b/drivers/nvmem/core.c
@@ -29,6 +29,7 @@
#define FLAG_COMPAT BIT(0)
struct nvmem_cell_entry {
struct kref refcnt;
+ bool disconnected;
struct nvmem_layout *layout;
const char *name;
int offset;
@@ -652,6 +653,7 @@ static int nvmem_cell_info_to_nvmem_cell_entry_nodup(struct nvmem_device *nvmem,
struct nvmem_cell_entry *cell)
{
cell->nvmem = nvmem;
+ cell->disconnected = false;
cell->offset = info->offset;
cell->raw_len = info->raw_len ?: info->bytes;
cell->bytes = info->bytes;
@@ -976,24 +978,44 @@ int nvmem_layout_register(struct nvmem_layout *layout)
return -ENODEV;
ret = layout->add_cells(layout);
}
- if (ret)
- return ret;
-
#ifdef CONFIG_NVMEM_SYSFS
- ret = nvmem_populate_sysfs_cells(layout->nvmem);
- if (ret) {
- nvmem_device_remove_all_cells(layout->nvmem);
- return ret;
- }
+ if (!ret)
+ ret = nvmem_populate_sysfs_cells(layout->nvmem);
#endif
-
- return 0;
+ if (ret)
+ nvmem_layout_unregister(layout);
+ return ret;
}
EXPORT_SYMBOL_GPL(nvmem_layout_register);

void nvmem_layout_unregister(struct nvmem_layout *layout)
{
- /* Keep the API even with an empty stub in case we need it later */
+ struct nvmem_device *nvmem = layout->nvmem;
+ struct nvmem_cell_entry *cell, *next;
+ LIST_HEAD(cells);
+
+ scoped_guard(mutex, &nvmem_mutex) {
+ list_for_each_entry_safe(cell, next, &nvmem->cells, node) {
+ if (cell->layout != layout)
+ continue;
+ WRITE_ONCE(cell->disconnected, true);
+ list_move_tail(&cell->node, &cells);
+ }
+ }
+
+ nvmem_sysfs_remove_cells(nvmem);
+
+ /* Old cell handles retain data, never a departing layout's callbacks. */
+ synchronize_srcu(&nvmem->srcu);
+ list_for_each_entry_safe(cell, next, &cells, node) {
+ srcu_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_REMOVE, cell);
+ list_del(&cell->node);
+ nvmem_cell_entry_put(cell);
+ }
+#ifdef CONFIG_NVMEM_SYSFS
+ if (rcu_access_pointer(nvmem->ops) && nvmem_populate_sysfs_cells(nvmem))
+ dev_warn(&nvmem->dev, "Failed to restore provider cell attributes\n");
+#endif
}
EXPORT_SYMBOL_GPL(nvmem_layout_unregister);

@@ -1506,12 +1528,6 @@ nvmem_cell_get_from_lookup(struct device *dev, const char *con_id)
return cell;
}

-static void nvmem_layout_module_put(struct nvmem_device *nvmem)
-{
- if (nvmem->layout && nvmem->layout->dev.driver)
- module_put(nvmem->layout->dev.driver->owner);
-}
-
#if IS_ENABLED(CONFIG_OF)
static struct nvmem_cell_entry *
nvmem_find_cell_entry_by_node(struct nvmem_device *nvmem, struct device_node *np)
@@ -1530,18 +1546,6 @@ nvmem_find_cell_entry_by_node(struct nvmem_device *nvmem, struct device_node *np
return NULL;
}

-static int nvmem_layout_module_get_optional(struct nvmem_device *nvmem)
-{
- if (!nvmem->layout)
- return 0;
-
- if (!nvmem->layout->dev.driver ||
- !try_module_get(nvmem->layout->dev.driver->owner))
- return -EPROBE_DEFER;
-
- return 0;
-}
-
/**
* of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
*
@@ -1604,25 +1608,16 @@ struct nvmem_cell *of_nvmem_cell_get(struct device_node *np, const char *id)
return ERR_CAST(nvmem);
}

- ret = nvmem_layout_module_get_optional(nvmem);
- if (ret) {
- of_node_put(cell_np);
- nvmem_device_put(nvmem);
- return ERR_PTR(ret);
- }
-
cell_entry = nvmem_find_cell_entry_by_node(nvmem, cell_np);
of_node_put(cell_np);
if (!cell_entry) {
- nvmem_layout_module_put(nvmem);
- ret = nvmem->layout ? -EPROBE_DEFER : -ENOENT;
+ ret = READ_ONCE(nvmem->layout) ? -EPROBE_DEFER : -ENOENT;
nvmem_device_put(nvmem);
return ERR_PTR(ret);
}

cell = nvmem_create_cell(cell_entry, id, cell_index);
if (IS_ERR(cell)) {
- nvmem_layout_module_put(nvmem);
nvmem_cell_entry_put(cell_entry);
nvmem_device_put(nvmem);
}
@@ -1739,7 +1734,6 @@ void nvmem_cell_put(struct nvmem_cell *cell)

nvmem_cell_entry_put(cell->entry);
kfree(cell);
- nvmem_layout_module_put(nvmem);
nvmem_device_put(nvmem);
}
EXPORT_SYMBOL_GPL(nvmem_cell_put);
@@ -1796,7 +1790,7 @@ static int __nvmem_cell_read(struct nvmem_device *nvmem,

guard(srcu)(&nvmem->srcu);
ops = srcu_dereference(nvmem->ops, &nvmem->srcu);
- if (!ops)
+ if (!ops || READ_ONCE(cell->disconnected))
return -ENODEV;

rc = nvmem_access_locked(nvmem, ops, cell->offset, buf, cell->raw_len, false);
@@ -1919,7 +1913,7 @@ static int __nvmem_cell_entry_write(struct nvmem_cell_entry *cell, void *buf, si

guard(srcu)(&nvmem->srcu);
ops = srcu_dereference(nvmem->ops, &nvmem->srcu);
- if (!ops)
+ if (!ops || READ_ONCE(cell->disconnected))
return -ENODEV;

if (nvmem->read_only || (cell->bit_offset == 0 && len != cell->bytes))
diff --git a/drivers/nvmem/layouts.c b/drivers/nvmem/layouts.c
index 409909e3244f..442947873591 100644
--- a/drivers/nvmem/layouts.c
+++ b/drivers/nvmem/layouts.c
@@ -118,6 +118,7 @@ static int nvmem_layout_create_device(struct nvmem_device *nvmem,

ret = device_add(dev);
if (ret) {
+ nvmem->layout = NULL;
put_device(dev);
return ret;
}
@@ -203,6 +204,7 @@ void nvmem_destroy_layout(struct nvmem_device *nvmem)
dev = &nvmem->layout->dev;
of_node_clear_flag(dev->of_node, OF_POPULATED_BUS);
device_unregister(dev);
+ WRITE_ONCE(nvmem->layout, NULL);
}

int nvmem_layout_bus_register(void)

--
2.53.0