Introduce an in-kernel test module to validate the core logic of the
Live Update Orchestrator's File-Lifecycle-Bound feature. This
provides a low-level, controlled environment to test FLB registration
and callback invocation without requiring userspace interaction or
actual kexec reboots.
The test is enabled by the CONFIG_LIVEUPDATE_TEST Kconfig option.
Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com>
---
kernel/liveupdate/luo_file.c | 2 +
kernel/liveupdate/luo_internal.h | 8 ++
lib/Kconfig.debug | 23 ++++++
lib/tests/Makefile | 1 +
lib/tests/liveupdate.c | 130 +++++++++++++++++++++++++++++++
5 files changed, 164 insertions(+)
create mode 100644 lib/tests/liveupdate.c
diff --git a/kernel/liveupdate/luo_file.c b/kernel/liveupdate/luo_file.c
index 713069b96278..4c0a75918f3d 100644
--- a/kernel/liveupdate/luo_file.c
+++ b/kernel/liveupdate/luo_file.c
@@ -829,6 +829,8 @@ int liveupdate_register_file_handler(struct liveupdate_file_handler *fh)
INIT_LIST_HEAD(&fh->flb_list);
list_add_tail(&fh->list, &luo_file_handler_list);
+ liveupdate_test_register(fh);
+
return 0;
}
diff --git a/kernel/liveupdate/luo_internal.h b/kernel/liveupdate/luo_internal.h
index 89c2fd97e5a7..be8986f7ac9b 100644
--- a/kernel/liveupdate/luo_internal.h
+++ b/kernel/liveupdate/luo_internal.h
@@ -90,4 +90,12 @@ int __init luo_flb_setup_outgoing(void *fdt);
int __init luo_flb_setup_incoming(void *fdt);
void luo_flb_serialize(void);
+#ifdef CONFIG_LIVEUPDATE_TEST
+void liveupdate_test_register(struct liveupdate_file_handler *h);
+#else
+static inline void liveupdate_test_register(struct liveupdate_file_handler *h)
+{
+}
+#endif
+
#endif /* _LINUX_LUO_INTERNAL_H */
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index ddacf9e665a2..2cbfa3dead0b 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -2813,6 +2813,29 @@ config LINEAR_RANGES_TEST
If unsure, say N.
+config LIVEUPDATE_TEST
+ bool "Live Update Kernel Test"
+ default n
+ depends on LIVEUPDATE
+ help
+ Enable a built-in kernel test module for the Live Update
+ Orchestrator.
+
+ This module validates the File-Lifecycle-Bound subsystem by
+ registering a set of mock FLB objects with any real file handlers
+ that support live update (such as the memfd handler).
+
+ When live update operations are performed, this test module will
+ output messages to the kernel log (dmesg), confirming that its
+ registration and various callback functions (preserve, retrieve,
+ finish, etc.) are being invoked correctly.
+
+ This is a debugging and regression testing tool for developers
+ working on the Live Update subsystem. It should not be enabled in
+ production kernels.
+
+ If unsure, say N
+
config CMDLINE_KUNIT_TEST
tristate "KUnit test for cmdline API" if !KUNIT_ALL_TESTS
depends on KUNIT
diff --git a/lib/tests/Makefile b/lib/tests/Makefile
index f7460831cfdd..8e5c527a94ac 100644
--- a/lib/tests/Makefile
+++ b/lib/tests/Makefile
@@ -27,6 +27,7 @@ obj-$(CONFIG_LIST_KUNIT_TEST) += list-test.o
obj-$(CONFIG_KFIFO_KUNIT_TEST) += kfifo_kunit.o
obj-$(CONFIG_TEST_LIST_SORT) += test_list_sort.o
obj-$(CONFIG_LINEAR_RANGES_TEST) += test_linear_ranges.o
+obj-$(CONFIG_LIVEUPDATE_TEST) += liveupdate.o
CFLAGS_longest_symbol_kunit.o += $(call cc-disable-warning, missing-prototypes)
obj-$(CONFIG_LONGEST_SYM_KUNIT_TEST) += longest_symbol_kunit.o
diff --git a/lib/tests/liveupdate.c b/lib/tests/liveupdate.c
new file mode 100644
index 000000000000..62c592aa859f
--- /dev/null
+++ b/lib/tests/liveupdate.c
@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/*
+ * Copyright (c) 2025, Google LLC.
+ * Pasha Tatashin <pasha.tatashin@soleen.com>
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME " test: " fmt
+
+#include <linux/init.h>
+#include <linux/liveupdate.h>
+#include <linux/module.h>
+#include "../../kernel/liveupdate/luo_internal.h"
+
+#define TEST_NFLBS 3
+#define TEST_FLB_MAGIC_BASE 0xFEEDF00DCAFEBEE0ULL
+
+static struct liveupdate_flb test_flbs[TEST_NFLBS];
+
+static int test_flb_preserve(struct liveupdate_flb_op_args *argp)
+{
+ ptrdiff_t index = argp->flb - test_flbs;
+
+ pr_info("%s: preserve was triggered\n", argp->flb->compatible);
+ argp->data = TEST_FLB_MAGIC_BASE + index;
+
+ return 0;
+}
+
+static void test_flb_unpreserve(struct liveupdate_flb_op_args *argp)
+{
+ pr_info("%s: unpreserve was triggered\n", argp->flb->compatible);
+}
+
+static void test_flb_retrieve(struct liveupdate_flb_op_args *argp)
+{
+ ptrdiff_t index = argp->flb - test_flbs;
+ u64 expected_data = TEST_FLB_MAGIC_BASE + index;
+
+ if (argp->data == expected_data) {
+ pr_info("%s: found flb data from the previous boot\n",
+ argp->flb->compatible);
+ argp->obj = (void *)argp->data;
+ } else {
+ pr_err("%s: ERROR - incorrect data handle: %llx, expected %llx\n",
+ argp->flb->compatible, argp->data, expected_data);
+ }
+}
+
+static void test_flb_finish(struct liveupdate_flb_op_args *argp)
+{
+ ptrdiff_t index = argp->flb - test_flbs;
+ void *expected_obj = (void *)(TEST_FLB_MAGIC_BASE + index);
+
+ if (argp->obj == expected_obj)
+ pr_info("%s: finish was triggered\n", argp->flb->compatible);
+ else
+ pr_err("%s: ERROR - finish called with invalid object\n",
+ argp->flb->compatible);
+}
+
+static const struct liveupdate_flb_ops test_flb_ops = {
+ .preserve = test_flb_preserve,
+ .unpreserve = test_flb_unpreserve,
+ .retrieve = test_flb_retrieve,
+ .finish = test_flb_finish,
+};
+
+#define DEFINE_TEST_FLB(i) \
+ { .ops = &test_flb_ops, .compatible = "test-flb-v" #i }
+
+static struct liveupdate_flb test_flbs[TEST_NFLBS] = {
+ DEFINE_TEST_FLB(0),
+ DEFINE_TEST_FLB(1),
+ DEFINE_TEST_FLB(2),
+};
+
+static int __init liveupdate_test_early_init(void)
+{
+ int i;
+
+ if (!liveupdate_enabled())
+ return 0;
+
+ for (i = 0; i < TEST_NFLBS; i++) {
+ struct liveupdate_flb *flb = &test_flbs[i];
+ void *obj;
+ int err;
+
+ liveupdate_init_flb(flb);
+
+ err = liveupdate_flb_incoming_locked(flb, &obj);
+ if (!err) {
+ liveupdate_flb_incoming_unlock(flb, obj);
+ } else if (err != -ENODATA && err != -ENOENT) {
+ pr_err("liveupdate_flb_incoming_locked for %s failed: %pe\n",
+ flb->compatible, ERR_PTR(err));
+ }
+ }
+
+ return 0;
+}
+early_initcall(liveupdate_test_early_init);
+
+void liveupdate_test_register(struct liveupdate_file_handler *h)
+{
+ int err, i;
+
+ for (i = 0; i < TEST_NFLBS; i++) {
+ struct liveupdate_flb *flb = &test_flbs[i];
+
+ err = liveupdate_register_flb(h, flb);
+ if (err)
+ pr_err("Failed to register %s %pe\n",
+ flb->compatible, ERR_PTR(err));
+ }
+
+ err = liveupdate_register_flb(h, &test_flbs[0]);
+ if (!err || err != -EEXIST) {
+ pr_err("Failed: %s should be already registered, but got err: %pe\n",
+ test_flbs[0].compatible, ERR_PTR(err));
+ }
+
+ pr_info("Registered %d FLBs with file handler: [%s]\n",
+ TEST_NFLBS, h->compatible);
+}
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Pasha Tatashin <pasha.tatashin@soleen.com>");
+MODULE_DESCRIPTION("In-kernel test for LUO mechanism");
--
2.51.2.1041.gc1ab5b90ca-googOn Fri, Nov 07, 2025 at 04:03:20PM -0500, Pasha Tatashin wrote: > Introduce an in-kernel test module to validate the core logic of the > Live Update Orchestrator's File-Lifecycle-Bound feature. This > provides a low-level, controlled environment to test FLB registration > and callback invocation without requiring userspace interaction or > actual kexec reboots. > > The test is enabled by the CONFIG_LIVEUPDATE_TEST Kconfig option. > > Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com> > --- > kernel/liveupdate/luo_file.c | 2 + > kernel/liveupdate/luo_internal.h | 8 ++ > lib/Kconfig.debug | 23 ++++++ > lib/tests/Makefile | 1 + > lib/tests/liveupdate.c | 130 +++++++++++++++++++++++++++++++ > 5 files changed, 164 insertions(+) > create mode 100644 lib/tests/liveupdate.c > > diff --git a/kernel/liveupdate/luo_file.c b/kernel/liveupdate/luo_file.c > index 713069b96278..4c0a75918f3d 100644 > --- a/kernel/liveupdate/luo_file.c > +++ b/kernel/liveupdate/luo_file.c > @@ -829,6 +829,8 @@ int liveupdate_register_file_handler(struct liveupdate_file_handler *fh) > INIT_LIST_HEAD(&fh->flb_list); > list_add_tail(&fh->list, &luo_file_handler_list); > > + liveupdate_test_register(fh); > + Do it mean that every flb user will be added here? > return 0; > } > -- Sincerely yours, Mike.
On Wed, Nov 12, 2025 at 3:24 PM Mike Rapoport <rppt@kernel.org> wrote: > > On Fri, Nov 07, 2025 at 04:03:20PM -0500, Pasha Tatashin wrote: > > Introduce an in-kernel test module to validate the core logic of the > > Live Update Orchestrator's File-Lifecycle-Bound feature. This > > provides a low-level, controlled environment to test FLB registration > > and callback invocation without requiring userspace interaction or > > actual kexec reboots. > > > > The test is enabled by the CONFIG_LIVEUPDATE_TEST Kconfig option. > > > > Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com> > > --- > > kernel/liveupdate/luo_file.c | 2 + > > kernel/liveupdate/luo_internal.h | 8 ++ > > lib/Kconfig.debug | 23 ++++++ > > lib/tests/Makefile | 1 + > > lib/tests/liveupdate.c | 130 +++++++++++++++++++++++++++++++ > > 5 files changed, 164 insertions(+) > > create mode 100644 lib/tests/liveupdate.c > > > > diff --git a/kernel/liveupdate/luo_file.c b/kernel/liveupdate/luo_file.c > > index 713069b96278..4c0a75918f3d 100644 > > --- a/kernel/liveupdate/luo_file.c > > +++ b/kernel/liveupdate/luo_file.c > > @@ -829,6 +829,8 @@ int liveupdate_register_file_handler(struct liveupdate_file_handler *fh) > > INIT_LIST_HEAD(&fh->flb_list); > > list_add_tail(&fh->list, &luo_file_handler_list); > > > > + liveupdate_test_register(fh); > > + > > Do it mean that every flb user will be added here? No, FLB users will use: liveupdate_register_flb() from various subsystems. This liveupdate_test_register() is only to allow kernel test to register test-FLBs to every single file-handler for in-kernel testing purpose only. Pasha
On Wed, Nov 12, 2025 at 03:40:53PM -0500, Pasha Tatashin wrote: > On Wed, Nov 12, 2025 at 3:24 PM Mike Rapoport <rppt@kernel.org> wrote: > > > > On Fri, Nov 07, 2025 at 04:03:20PM -0500, Pasha Tatashin wrote: > > > Introduce an in-kernel test module to validate the core logic of the > > > Live Update Orchestrator's File-Lifecycle-Bound feature. This > > > provides a low-level, controlled environment to test FLB registration > > > and callback invocation without requiring userspace interaction or > > > actual kexec reboots. > > > > > > The test is enabled by the CONFIG_LIVEUPDATE_TEST Kconfig option. > > > > > > Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com> > > > --- > > > kernel/liveupdate/luo_file.c | 2 + > > > kernel/liveupdate/luo_internal.h | 8 ++ > > > lib/Kconfig.debug | 23 ++++++ > > > lib/tests/Makefile | 1 + > > > lib/tests/liveupdate.c | 130 +++++++++++++++++++++++++++++++ > > > 5 files changed, 164 insertions(+) > > > create mode 100644 lib/tests/liveupdate.c > > > > > > diff --git a/kernel/liveupdate/luo_file.c b/kernel/liveupdate/luo_file.c > > > index 713069b96278..4c0a75918f3d 100644 > > > --- a/kernel/liveupdate/luo_file.c > > > +++ b/kernel/liveupdate/luo_file.c > > > @@ -829,6 +829,8 @@ int liveupdate_register_file_handler(struct liveupdate_file_handler *fh) > > > INIT_LIST_HEAD(&fh->flb_list); > > > list_add_tail(&fh->list, &luo_file_handler_list); > > > > > > + liveupdate_test_register(fh); > > > + > > > > Do it mean that every flb user will be added here? > > No, FLB users will use: > > liveupdate_register_flb() from various subsystems. This > liveupdate_test_register() is only to allow kernel test to register > test-FLBs to every single file-handler for in-kernel testing purpose > only. Why the in kernel test cannot liveupdate_register_flb()? > Pasha -- Sincerely yours, Mike.
On Sun, Nov 16, 2025 at 1:36 PM Mike Rapoport <rppt@kernel.org> wrote: > > On Wed, Nov 12, 2025 at 03:40:53PM -0500, Pasha Tatashin wrote: > > On Wed, Nov 12, 2025 at 3:24 PM Mike Rapoport <rppt@kernel.org> wrote: > > > > > > On Fri, Nov 07, 2025 at 04:03:20PM -0500, Pasha Tatashin wrote: > > > > Introduce an in-kernel test module to validate the core logic of the > > > > Live Update Orchestrator's File-Lifecycle-Bound feature. This > > > > provides a low-level, controlled environment to test FLB registration > > > > and callback invocation without requiring userspace interaction or > > > > actual kexec reboots. > > > > > > > > The test is enabled by the CONFIG_LIVEUPDATE_TEST Kconfig option. > > > > > > > > Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com> > > > > --- > > > > kernel/liveupdate/luo_file.c | 2 + > > > > kernel/liveupdate/luo_internal.h | 8 ++ > > > > lib/Kconfig.debug | 23 ++++++ > > > > lib/tests/Makefile | 1 + > > > > lib/tests/liveupdate.c | 130 +++++++++++++++++++++++++++++++ > > > > 5 files changed, 164 insertions(+) > > > > create mode 100644 lib/tests/liveupdate.c > > > > > > > > diff --git a/kernel/liveupdate/luo_file.c b/kernel/liveupdate/luo_file.c > > > > index 713069b96278..4c0a75918f3d 100644 > > > > --- a/kernel/liveupdate/luo_file.c > > > > +++ b/kernel/liveupdate/luo_file.c > > > > @@ -829,6 +829,8 @@ int liveupdate_register_file_handler(struct liveupdate_file_handler *fh) > > > > INIT_LIST_HEAD(&fh->flb_list); > > > > list_add_tail(&fh->list, &luo_file_handler_list); > > > > > > > > + liveupdate_test_register(fh); > > > > + > > > > > > Do it mean that every flb user will be added here? > > > > No, FLB users will use: > > > > liveupdate_register_flb() from various subsystems. This > > liveupdate_test_register() is only to allow kernel test to register > > test-FLBs to every single file-handler for in-kernel testing purpose > > only. > > Why the in kernel test cannot liveupdate_register_flb()? The kernel tests call liveupdate_register_flb() with every file-handler that registers with LUO. It is unreasonable to expect that all file handlers from various subsystems are going to be exported and accessible to kernel test. > > > Pasha > > -- > Sincerely yours, > Mike.
© 2016 - 2026 Red Hat, Inc.