[RFC v2 14/16] selftests/liveupdate: add subsystem/state tests

[Pasha Tatashin <pasha.tatashin@soleen.com>]

Introduces a new set of userspace selftests for the LUO. These tests
verify the functionality LUO by using the kernel-side selftest ioctls
provided by the LUO module, primarily focusing on subsystem management
and basic LUO state transitions.

Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com>
---
 tools/testing/selftests/Makefile              |   1 +
 tools/testing/selftests/liveupdate/.gitignore |   1 +
 tools/testing/selftests/liveupdate/Makefile   |   7 +
 tools/testing/selftests/liveupdate/config     |   6 +
 .../testing/selftests/liveupdate/liveupdate.c | 440 ++++++++++++++++++
 5 files changed, 455 insertions(+)
 create mode 100644 tools/testing/selftests/liveupdate/.gitignore
 create mode 100644 tools/testing/selftests/liveupdate/Makefile
 create mode 100644 tools/testing/selftests/liveupdate/config
 create mode 100644 tools/testing/selftests/liveupdate/liveupdate.c

diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 80fb84fa3cfc..1a96e806a5dd 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -52,6 +52,7 @@ TARGETS += kvm
 TARGETS += landlock
 TARGETS += lib
 TARGETS += livepatch
+TARGETS += liveupdate
 TARGETS += lkdtm
 TARGETS += lsm
 TARGETS += membarrier
diff --git a/tools/testing/selftests/liveupdate/.gitignore b/tools/testing/selftests/liveupdate/.gitignore
new file mode 100644
index 000000000000..af6e773cf98f
--- /dev/null
+++ b/tools/testing/selftests/liveupdate/.gitignore
@@ -0,0 +1 @@
+/liveupdate
diff --git a/tools/testing/selftests/liveupdate/Makefile b/tools/testing/selftests/liveupdate/Makefile
new file mode 100644
index 000000000000..2a573c36016e
--- /dev/null
+++ b/tools/testing/selftests/liveupdate/Makefile
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: GPL-2.0-only
+CFLAGS += -Wall -O2 -Wno-unused-function
+CFLAGS += $(KHDR_INCLUDES)
+
+TEST_GEN_PROGS += liveupdate
+
+include ../lib.mk
diff --git a/tools/testing/selftests/liveupdate/config b/tools/testing/selftests/liveupdate/config
new file mode 100644
index 000000000000..382c85b89570
--- /dev/null
+++ b/tools/testing/selftests/liveupdate/config
@@ -0,0 +1,6 @@
+CONFIG_KEXEC_FILE=y
+CONFIG_KEXEC_HANDOVER=y
+CONFIG_KEXEC_HANDOVER_DEBUG=y
+CONFIG_LIVEUPDATE=y
+CONFIG_LIVEUPDATE_SYSFS_API=y
+CONFIG_LIVEUPDATE_SELFTESTS=y
diff --git a/tools/testing/selftests/liveupdate/liveupdate.c b/tools/testing/selftests/liveupdate/liveupdate.c
new file mode 100644
index 000000000000..0007085e2b96
--- /dev/null
+++ b/tools/testing/selftests/liveupdate/liveupdate.c
@@ -0,0 +1,440 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+/*
+ * Copyright (c) 2025, Google LLC.
+ * Pasha Tatashin <pasha.tatashin@soleen.com>
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+
+#include <linux/liveupdate.h>
+
+#include "../kselftest.h"
+#include "../kselftest_harness.h"
+#include "../../../../drivers/misc/liveupdate/luo_selftests.h"
+
+struct subsystem_info {
+	void *data_page;
+	void *verify_page;
+	char test_name[LUO_NAME_LENGTH];
+	bool registered;
+};
+
+FIXTURE(subsystem) {
+	enum liveupdate_state state;
+	int fd;
+	struct subsystem_info si[LUO_MAX_SUBSYSTEMS];
+};
+
+FIXTURE(state) {
+	enum liveupdate_state state;
+	int fd;
+};
+
+#define LUO_DEVICE	"/dev/liveupdate"
+#define LUO_SYSFS_STATE	"/sys/kernel/liveupdate/state"
+static size_t page_size;
+
+const char *const luo_state_str[] = {
+	[LIVEUPDATE_STATE_NORMAL]   = "normal",
+	[LIVEUPDATE_STATE_PREPARED] = "prepared",
+	[LIVEUPDATE_STATE_FROZEN]   = "frozen",
+	[LIVEUPDATE_STATE_UPDATED]  = "updated",
+};
+
+static int run_luo_selftest_cmd(int fd, __u64 cmd_code,
+				struct luo_arg_subsystem *subsys_arg)
+{
+	struct liveupdate_selftest k_arg;
+
+	if (fd < 0) {
+		errno = EBADF;
+		return -1;
+	}
+
+	k_arg.cmd = cmd_code;
+	k_arg.arg = (__u64)(unsigned long)subsys_arg;
+
+	return ioctl(fd, LIVEUPDATE_IOCTL_SELFTESTS, &k_arg);
+}
+
+static int __register_subsystem(int fd, char *name, void *data_page)
+{
+	struct luo_arg_subsystem subsys_arg;
+
+	memset(&subsys_arg, 0, sizeof(subsys_arg));
+	snprintf(subsys_arg.name, LUO_NAME_LENGTH, "%s", name);
+	subsys_arg.data_page = data_page;
+
+	return run_luo_selftest_cmd(fd, LUO_CMD_SUBSYSTEM_REGISTER,
+				    &subsys_arg);
+}
+
+static int __unregister_subsystem(int fd, char *name)
+{
+	struct luo_arg_subsystem subsys_arg;
+
+	memset(&subsys_arg, 0, sizeof(subsys_arg));
+	snprintf(subsys_arg.name, LUO_NAME_LENGTH, "%s", name);
+
+	return run_luo_selftest_cmd(fd, LUO_CMD_SUBSYSTEM_UNREGISTER,
+				    &subsys_arg);
+}
+
+static int get_sysfs_state(void)
+{
+	char buf[64];
+	ssize_t len;
+	int fd, i;
+
+	fd = open(LUO_SYSFS_STATE, O_RDONLY);
+	if (fd < 0) {
+		ksft_print_msg("Failed to open sysfs state file '%s': %s\n",
+			       LUO_SYSFS_STATE, strerror(errno));
+		return -errno;
+	}
+
+	len = read(fd, buf, sizeof(buf) - 1);
+	close(fd);
+
+	if (len <= 0) {
+		ksft_print_msg("Failed to read sysfs state file '%s': %s\n",
+			       LUO_SYSFS_STATE, strerror(errno));
+		return -errno;
+	}
+	if (buf[len - 1] == '\n')
+		buf[len - 1] = '\0';
+	else
+		buf[len] = '\0';
+
+	for (i = 0; i < ARRAY_SIZE(luo_state_str); i++) {
+		if (!strcmp(buf, luo_state_str[i]))
+			return i;
+	}
+
+	return -EIO;
+}
+
+FIXTURE_SETUP(state)
+{
+	page_size = sysconf(_SC_PAGE_SIZE);
+	self->fd = open(LUO_DEVICE, O_RDWR);
+	if (self->fd < 0) {
+		ksft_exit_skip("Setup: Cannot open %s (errno %d).\n",
+			       LUO_DEVICE, errno);
+	}
+	self->state = LIVEUPDATE_STATE_NORMAL;
+}
+
+FIXTURE_TEARDOWN(state)
+{
+	page_size = sysconf(_SC_PAGE_SIZE);
+	if (self->state != LIVEUPDATE_STATE_NORMAL)
+		ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_CANCEL, NULL);
+	close(self->fd);
+}
+
+FIXTURE_SETUP(subsystem)
+{
+	int i;
+
+	page_size = sysconf(_SC_PAGE_SIZE);
+	memset(&self->si, 0, sizeof(self->si));
+	self->fd = open(LUO_DEVICE, O_RDWR);
+	if (self->fd < 0) {
+		ksft_exit_skip("Setup: Cannot open %s (errno %d).\n",
+			       LUO_DEVICE, errno);
+	}
+	self->state = LIVEUPDATE_STATE_NORMAL;
+
+	for (i = 0; i < LUO_MAX_SUBSYSTEMS; i++) {
+		snprintf(self->si[i].test_name, LUO_NAME_LENGTH,
+			 "ksft_luo_%d.%d", getpid(), i);
+
+		self->si[i].data_page = mmap(NULL, page_size,
+					     PROT_READ | PROT_WRITE,
+					     MAP_PRIVATE | MAP_ANONYMOUS,
+					     -1, 0);
+
+		if (self->si[i].data_page == MAP_FAILED) {
+			ksft_print_msg("Setup: mmap data_page failed\n");
+			goto exit_fail;
+		}
+		memset(self->si[i].data_page, 'A' + i, page_size);
+
+		self->si[i].verify_page = mmap(NULL, page_size,
+					       PROT_READ | PROT_WRITE,
+					       MAP_PRIVATE | MAP_ANONYMOUS,
+					       -1, 0);
+		if (self->si[i].verify_page == MAP_FAILED) {
+			ksft_print_msg("Setup: mmap verify_page failed\n");
+			goto exit_fail;
+		}
+		memset(self->si[i].verify_page, 0, page_size);
+	}
+
+	return;
+exit_fail:
+	close(self->fd);
+
+	for (i = 0; i < LUO_MAX_SUBSYSTEMS; i++) {
+		void *page;
+
+		page = self->si[i].data_page;
+		if (page && page != MAP_FAILED)
+			munmap(page, page_size);
+
+		page = self->si[i].verify_page;
+		if (page && page != MAP_FAILED)
+			munmap(page, page_size);
+	}
+	ksft_exit_fail();
+}
+
+FIXTURE_TEARDOWN(subsystem)
+{
+	int i;
+
+	if (self->state != LIVEUPDATE_STATE_NORMAL)
+		ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_CANCEL, NULL);
+
+	for (i = 0; i < LUO_MAX_SUBSYSTEMS; i++) {
+		if (self->si[i].registered) {
+			struct luo_arg_subsystem subsys_arg;
+
+			memset(&subsys_arg, 0, sizeof(subsys_arg));
+			snprintf(subsys_arg.name, LUO_NAME_LENGTH, "%s",
+				 self->si[i].test_name);
+			subsys_arg.data_page = NULL;
+			run_luo_selftest_cmd(self->fd, LUO_CMD_SUBSYSTEM_UNREGISTER,
+					     &subsys_arg);
+		}
+		munmap(self->si[i].data_page, page_size);
+		munmap(self->si[i].verify_page, page_size);
+	}
+
+	close(self->fd);
+}
+
+TEST_F(state, normal)
+{
+	enum liveupdate_state state;
+	int ret;
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_GET_STATE, &state);
+	ASSERT_EQ(0, ret);
+	ASSERT_EQ(state, LIVEUPDATE_STATE_NORMAL);
+}
+
+TEST_F(state, prepared)
+{
+	enum liveupdate_state state;
+	int ret;
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_PREPARE, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_PREPARED;
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_GET_STATE, &state);
+	ASSERT_EQ(0, ret);
+	ASSERT_EQ(state, LIVEUPDATE_STATE_PREPARED);
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_CANCEL, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_NORMAL;
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_GET_STATE, &state);
+	ASSERT_EQ(0, ret);
+	ASSERT_EQ(state, LIVEUPDATE_STATE_NORMAL);
+}
+
+TEST_F(state, sysfs_normal)
+{
+	int state = get_sysfs_state();
+
+	if (state < 0) {
+		if (state == -ENOENT || state == -EACCES) {
+			ksft_test_result_skip("Sysfs state file not accessible (%d)\n",
+					      state);
+			return;
+		}
+	}
+
+	ASSERT_EQ(LIVEUPDATE_STATE_NORMAL, state);
+}
+
+TEST_F(state, sysfs_prepared)
+{
+	int ret, state;
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_PREPARE, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_PREPARED;
+
+	state = get_sysfs_state();
+	if (state < 0) {
+		if (state == -ENOENT || state == -EACCES) {
+			ksft_test_result_skip("Sysfs state file not accessible (%d)\n",
+					      state);
+			ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_CANCEL, NULL);
+			self->state = LIVEUPDATE_STATE_NORMAL;
+			return;
+		}
+	}
+	ASSERT_EQ(LIVEUPDATE_STATE_PREPARED, state);
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_CANCEL, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_NORMAL;
+	state = get_sysfs_state();
+	ASSERT_EQ(LIVEUPDATE_STATE_NORMAL, state);
+}
+
+TEST_F(state, sysfs_frozen)
+{
+	int ret, state;
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_PREPARE, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_PREPARED;
+
+	state = get_sysfs_state();
+	if (state < 0) {
+		if (state == -ENOENT || state == -EACCES) {
+			ksft_test_result_skip("Sysfs state file not accessible (%d)\n", state);
+			ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_CANCEL, NULL);
+			self->state = LIVEUPDATE_STATE_NORMAL;
+			return;
+		}
+	}
+	ASSERT_EQ(LIVEUPDATE_STATE_PREPARED, state);
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_FREEZE, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_FROZEN;
+	state = get_sysfs_state();
+	ASSERT_EQ(LIVEUPDATE_STATE_FROZEN, state);
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_CANCEL, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_NORMAL;
+	state = get_sysfs_state();
+	ASSERT_EQ(LIVEUPDATE_STATE_NORMAL, state);
+}
+
+TEST_F(subsystem, register_unregister)
+{
+	int ret;
+
+	ret = __register_subsystem(self->fd, self->si[0].test_name,
+				   self->si[0].data_page);
+	ASSERT_EQ(0, ret);
+	self->si[0].registered = true;
+
+	ret = __unregister_subsystem(self->fd, self->si[0].test_name);
+	ASSERT_EQ(0, ret);
+	self->si[0].registered = false;
+}
+
+TEST_F(subsystem, double_unregister)
+{
+	int ret;
+
+	ret = __register_subsystem(self->fd, self->si[0].test_name,
+				   self->si[0].data_page);
+	ASSERT_EQ(0, ret);
+	self->si[0].registered = true;
+
+	ret = __unregister_subsystem(self->fd, self->si[0].test_name);
+	ASSERT_EQ(0, ret);
+	self->si[0].registered = false;
+
+	ret = __unregister_subsystem(self->fd, self->si[0].test_name);
+	EXPECT_NE(0, ret);
+	EXPECT_TRUE(errno == EINVAL || errno == ENOENT);
+	self->si[0].registered = false;
+}
+
+TEST_F(subsystem, register_unregister_many)
+{
+	int ret;
+	int i;
+
+	for (i = 0; i < LUO_MAX_SUBSYSTEMS; i++) {
+		ret = __register_subsystem(self->fd, self->si[i].test_name,
+					   self->si[i].data_page);
+		ASSERT_EQ(0, ret);
+		self->si[i].registered = true;
+	}
+
+	for (i = 0; i < LUO_MAX_SUBSYSTEMS; i++) {
+		ret = __unregister_subsystem(self->fd, self->si[i].test_name);
+		ASSERT_EQ(0, ret);
+		self->si[i].registered = false;
+	}
+
+}
+
+TEST_F(subsystem, getdata_verify)
+{
+	enum liveupdate_state state;
+	int ret;
+	int i;
+
+	for (i = 0; i < LUO_MAX_SUBSYSTEMS; i++) {
+		ret = __register_subsystem(self->fd, self->si[i].test_name,
+					   self->si[i].data_page);
+		ASSERT_EQ(0, ret);
+		self->si[i].registered = true;
+	}
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_PREPARE, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_PREPARED;
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_GET_STATE, &state);
+	ASSERT_EQ(0, ret);
+	ASSERT_EQ(state, LIVEUPDATE_STATE_PREPARED);
+
+	for (i = 0; i < LUO_MAX_SUBSYSTEMS; i++) {
+		struct luo_arg_subsystem subsys_arg;
+
+		memset(&subsys_arg, 0, sizeof(subsys_arg));
+		snprintf(subsys_arg.name, LUO_NAME_LENGTH, "%s",
+			 self->si[i].test_name);
+		subsys_arg.data_page = self->si[i].verify_page;
+
+		ret = run_luo_selftest_cmd(self->fd, LUO_CMD_SUBSYSTEM_GETDATA,
+					   &subsys_arg);
+
+		ASSERT_EQ(0, ret);
+		ASSERT_EQ(0, memcmp(self->si[i].data_page,
+				    self->si[i].verify_page,
+				    page_size));
+	}
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_EVENT_CANCEL, NULL);
+	ASSERT_EQ(0, ret);
+	self->state = LIVEUPDATE_STATE_NORMAL;
+
+	ret = ioctl(self->fd, LIVEUPDATE_IOCTL_GET_STATE, &state);
+	ASSERT_EQ(0, ret);
+	ASSERT_EQ(state, LIVEUPDATE_STATE_NORMAL);
+
+	for (i = 0; i < LUO_MAX_SUBSYSTEMS; i++) {
+		ret = __unregister_subsystem(self->fd, self->si[i].test_name);
+		ASSERT_EQ(0, ret);
+		self->si[i].registered = false;
+	}
+}
+
+TEST_HARNESS_MAIN
-- 
2.49.0.1101.gccaa498523-goog