[PATCH 14/19] test: self: add devm_ selftest
Ahmad Fatoum
a.fatoum at pengutronix.de
Wed Oct 28 02:14:48 PDT 2026
From: Ahmad Fatoum <a.fatoum at barebox.org>
Check alignment, zeroing, early devm_kfree() and action order as well
as the release points: failed probe, remove, unbind of a driver without
.remove and unregistering a device with children in managed memory.
Also check that shutdown runs the actions, but keeps the memory.
Assisted-by: Claude:fable-5.1
Signed-off-by: Ahmad Fatoum <a.fatoum at barebox.org>
---
test/self/Kconfig | 6 +
test/self/Makefile | 1 +
test/self/devres.c | 289 +++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 296 insertions(+)
create mode 100644 test/self/devres.c
diff --git a/test/self/Kconfig b/test/self/Kconfig
index bdee21f17d7e..e655740c41cb 100644
--- a/test/self/Kconfig
+++ b/test/self/Kconfig
@@ -53,6 +53,7 @@ config SELFTEST_ENABLE_ALL
select SELFTEST_DM
select SELFTEST_LVM if BLOCK
select SELFTEST_TALLOC
+ select SELFTEST_DEVRES
select SELFTEST_BLSPEC if BLSPEC && DEFAULT_ENVIRONMENT
help
Selects all self-tests compatible with current configuration
@@ -87,6 +88,11 @@ config SELFTEST_TALLOC
help
Tests barebox talloc allocator
+config SELFTEST_DEVRES
+ bool "devm_ selftest"
+ help
+ Tests device-managed resources
+
config SELFTEST_PRINTF
bool "printf selftest"
help
diff --git a/test/self/Makefile b/test/self/Makefile
index 0fba7ac56654..337a211d761c 100644
--- a/test/self/Makefile
+++ b/test/self/Makefile
@@ -6,6 +6,7 @@ obj-$(CONFIG_SELFTEST_RANGE) += range.o
obj-$(CONFIG_SELFTEST_MALLOC) += malloc.o
obj-$(CONFIG_SELFTEST_CLEANUP) += cleanup.o
obj-$(CONFIG_SELFTEST_TALLOC) += talloc.o
+obj-$(CONFIG_SELFTEST_DEVRES) += devres.o
obj-$(CONFIG_SELFTEST_PRINTF) += printf.o
CFLAGS_printf.o += -Wno-format-security -Wno-format
obj-$(CONFIG_SELFTEST_PROGRESS_NOTIFIER) += progress-notifier.o
diff --git a/test/self/devres.c b/test/self/devres.c
new file mode 100644
index 000000000000..4fdc71064b4a
--- /dev/null
+++ b/test/self/devres.c
@@ -0,0 +1,289 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#define pr_fmt(fmt) "devres: " fmt
+
+#include <common.h>
+#include <bselftest.h>
+#include <dma.h>
+#include <linux/bitmap.h>
+#include <driver.h>
+#include <linux/device.h>
+
+BSELFTEST_GLOBALS();
+
+static bool __selftest_check(bool cond, const char *func, int line)
+{
+ total_tests++;
+ if (cond)
+ return true;
+
+ pr_err("assertion failure at %s:%d\n", func, line);
+
+ failed_tests++;
+ return false;
+}
+#define selftest_check(cond) __selftest_check((cond), __func__, __LINE__)
+
+static char action_log[8];
+static unsigned action_log_len;
+
+static void log_action(void *data)
+{
+ if (action_log_len < sizeof(action_log) - 1)
+ action_log[action_log_len++] = *(char *)data;
+}
+
+static void reset_action_log(void)
+{
+ memset(action_log, 0, sizeof(action_log));
+ action_log_len = 0;
+}
+
+static void test_devres_alloc(void)
+{
+ struct device *dev = device_alloc("devres-test", DEVICE_ID_DYNAMIC);
+ unsigned long *bitmap;
+ const char *cstr;
+ char *str, *buf;
+ int *arr;
+
+ if (selftest_check(register_device(dev) == 0) == false)
+ return;
+
+ buf = devm_kmalloc(dev, 1, GFP_KERNEL);
+ selftest_check(buf && PTR_IS_ALIGNED(buf, DMA_ALIGNMENT));
+ buf[0] = 0xff;
+
+ arr = devm_kzalloc_objs(dev, *arr, 100);
+ selftest_check(arr && PTR_IS_ALIGNED(arr, DMA_ALIGNMENT));
+ selftest_check(memchr_inv(arr, 0, 100 * sizeof(*arr)) == NULL);
+ arr[0] = 42;
+ arr[99] = 42;
+
+ bitmap = devm_bitmap_zalloc(dev, 100, GFP_KERNEL);
+ selftest_check(bitmap && bitmap_empty(bitmap, 100));
+
+ str = devm_kstrdup(dev, "hello", GFP_KERNEL);
+ selftest_check(str && !strcmp(str, "hello"));
+ selftest_check(devm_kstrdup(dev, NULL, GFP_KERNEL) == NULL);
+
+ cstr = devm_kstrdup_const(dev, "const", GFP_KERNEL);
+ selftest_check(cstr && !strcmp(cstr, "const"));
+
+ str = devm_kasprintf(dev, GFP_KERNEL, "%s%d", "test", 123);
+ selftest_check(str && !strcmp(str, "test123"));
+
+ selftest_check(devm_kmalloc(dev, 0, GFP_KERNEL) == ZERO_SIZE_PTR);
+
+ /* Early frees, including the ones that must be no-ops */
+ devm_kfree(dev, arr);
+ devm_kfree(dev, cstr);
+ devm_kfree(dev, NULL);
+ devm_kfree(dev, ZERO_SIZE_PTR);
+
+ selftest_check(buf[0] == 0xff && !strcmp(str, "test123"));
+ selftest_check(dev->devres != NULL);
+
+ unregister_device(dev);
+ selftest_check(dev->devres == NULL);
+ free_device(dev);
+}
+
+static void test_devres_action(void)
+{
+ struct device *dev = device_alloc("devres-test", DEVICE_ID_DYNAMIC);
+ static char a = 'a', b = 'b', c = 'c';
+
+ if (selftest_check(register_device(dev) == 0) == false)
+ return;
+
+ reset_action_log();
+
+ selftest_check(devm_add_action(dev, log_action, &a) == 0);
+ selftest_check(devm_add_action_or_reset(dev, log_action, &b) == 0);
+ selftest_check(devm_add_action(dev, log_action, &c) == 0);
+ selftest_check(action_log_len == 0);
+
+ /* Actions run in reverse order of registration */
+ unregister_device(dev);
+ selftest_check(!strcmp(action_log, "cba"));
+ free_device(dev);
+}
+
+static void test_devres_shutdown(void)
+{
+ struct device *dev = device_alloc("devres-test", DEVICE_ID_DYNAMIC);
+ static char a = 'a', b = 'b';
+ char *buf;
+
+ if (selftest_check(register_device(dev) == 0) == false)
+ return;
+
+ reset_action_log();
+
+ buf = devm_kstrdup(dev, "kept", GFP_KERNEL);
+ selftest_check(devm_add_action(dev, log_action, &a) == 0);
+ selftest_check(devm_add_action(dev, log_action, &b) == 0);
+
+ /* Shutdown runs the actions, but keeps the memory */
+ devres_run_actions(dev);
+ selftest_check(!strcmp(action_log, "ba"));
+ selftest_check(!strcmp(buf, "kept"));
+
+ /* Releasing doesn't run them again */
+ unregister_device(dev);
+ selftest_check(!strcmp(action_log, "ba"));
+ free_device(dev);
+}
+
+static int probe_result;
+static char *probe_buf;
+
+static int devres_test_probe(struct device *dev)
+{
+ static char p = 'p';
+
+ probe_buf = devm_kzalloc(dev, 16, GFP_KERNEL);
+ strcpy(probe_buf, "probed");
+ devm_add_action(dev, log_action, &p);
+
+ return probe_result;
+}
+
+static void devres_test_remove(struct device *dev)
+{
+ static char r = 'r';
+
+ /* Managed resources must still be intact during remove */
+ log_action(&r);
+ selftest_check(!strcmp(probe_buf, "probed"));
+}
+
+static struct driver devres_test_driver = {
+ .name = "devres-test",
+ .probe = devres_test_probe,
+ .remove = devres_test_remove,
+};
+
+static void test_devres_probe(void)
+{
+ struct device *dev;
+
+ if (selftest_check(platform_driver_register(&devres_test_driver) == 0) == false)
+ return;
+
+ /* Failed probe releases everything */
+ reset_action_log();
+ probe_result = -ENODEV;
+ dev = device_alloc("devres-test", DEVICE_ID_DYNAMIC);
+ platform_device_register(dev);
+ selftest_check(dev->driver == NULL);
+ selftest_check(!strcmp(action_log, "p"));
+ selftest_check(dev->devres == NULL);
+ unregister_device(dev);
+ free_device(dev);
+
+ /* Successful probe keeps everything until remove */
+ reset_action_log();
+ probe_result = 0;
+ dev = device_alloc("devres-test", DEVICE_ID_DYNAMIC);
+ platform_device_register(dev);
+ selftest_check(dev->driver == &devres_test_driver);
+ selftest_check(action_log_len == 0);
+ selftest_check(dev->devres != NULL);
+ unregister_device(dev);
+ selftest_check(!strcmp(action_log, "rp"));
+ selftest_check(dev->devres == NULL);
+ free_device(dev);
+
+ unregister_driver(&devres_test_driver);
+}
+
+static int devres_noremove_probe(struct device *dev)
+{
+ static char n = 'n';
+
+ devm_add_action(dev, log_action, &n);
+
+ return 0;
+}
+
+static struct driver devres_noremove_driver = {
+ .name = "devres-noremove",
+ .probe = devres_noremove_probe,
+};
+
+static void test_devres_unbind(void)
+{
+ struct device *dev;
+
+ if (selftest_check(platform_driver_register(&devres_noremove_driver) == 0) == false)
+ return;
+
+ reset_action_log();
+ dev = device_alloc("devres-noremove", DEVICE_ID_DYNAMIC);
+ platform_device_register(dev);
+ selftest_check(dev->driver == &devres_noremove_driver);
+ selftest_check(dev->devres != NULL);
+
+ /* A driver without remove callback releases its resources as well */
+ unregister_driver(&devres_noremove_driver);
+ selftest_check(dev->driver == NULL);
+ selftest_check(dev->devres == NULL);
+ selftest_check(!strcmp(action_log, "n"));
+
+ unregister_device(dev);
+ free_device(dev);
+}
+
+struct devres_parent_priv {
+ struct device child;
+};
+
+static int devres_parent_probe(struct device *dev)
+{
+ struct devres_parent_priv *priv;
+
+ priv = devm_kzalloc_obj(dev, *priv);
+ dev_set_name(&priv->child, "devres-child");
+ priv->child.id = DEVICE_ID_DYNAMIC;
+ priv->child.parent = dev;
+
+ return register_device(&priv->child);
+}
+
+static struct driver devres_parent_driver = {
+ .name = "devres-parent",
+ .probe = devres_parent_probe,
+};
+
+static void test_devres_child(void)
+{
+ struct device *dev;
+
+ if (selftest_check(platform_driver_register(&devres_parent_driver) == 0) == false)
+ return;
+
+ dev = device_alloc("devres-parent", DEVICE_ID_DYNAMIC);
+ platform_device_register(dev);
+ selftest_check(dev->driver == &devres_parent_driver);
+ selftest_check(!list_empty(&dev->children));
+
+ /* The child lives in managed memory and must be unregistered first */
+ unregister_device(dev);
+ selftest_check(dev->devres == NULL);
+ free_device(dev);
+
+ unregister_driver(&devres_parent_driver);
+}
+
+static void test_devres(void)
+{
+ test_devres_alloc();
+ test_devres_action();
+ test_devres_shutdown();
+ test_devres_probe();
+ test_devres_unbind();
+ test_devres_child();
+}
+bselftest(core, test_devres);
--
2.47.3
More information about the barebox
mailing list