Add the testing infrastructure required to verify the liveupdate
feature. This includes a custom init process, a test orchestration
script, and a batch runner.
The framework consists of:
init.c:
A lightweight init process that manages the kexec lifecycle.
It mounts necessary filesystems, determines the current execution
stage (1 or 2) via the kernel command line, and handles the
kexec_file_load() sequence to transition between kernels.
luo_test.sh:
The primary KTAP-compliant test driver. It handles:
- Kernel configuration merging and building.
- Cross-compilation detection for x86_64 and arm64.
- Generation of the initrd containing the test binary and init.
- QEMU execution with automatic accelerator detection (KVM, HVF,
or TCG).
run.sh:
A wrapper script to discover and execute all `luo_*.c`
tests across supported architectures, providing a summary of
pass/fail/skip results.
Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com>
---
tools/testing/selftests/liveupdate/init.c | 174 ++++++++++
.../testing/selftests/liveupdate/luo_test.sh | 296 ++++++++++++++++++
tools/testing/selftests/liveupdate/run.sh | 68 ++++
3 files changed, 538 insertions(+)
create mode 100644 tools/testing/selftests/liveupdate/init.c
create mode 100755 tools/testing/selftests/liveupdate/luo_test.sh
create mode 100755 tools/testing/selftests/liveupdate/run.sh
diff --git a/tools/testing/selftests/liveupdate/init.c b/tools/testing/selftests/liveupdate/init.c
new file mode 100644
index 000000000000..ed11e04d0796
--- /dev/null
+++ b/tools/testing/selftests/liveupdate/init.c
@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/*
+ * Copyright (c) 2025, Google LLC.
+ * Pasha Tatashin <pasha.tatashin@soleen.com>
+ */
+#include <fcntl.h>
+#include <linux/kexec.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mount.h>
+#include <sys/reboot.h>
+#include <sys/syscall.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#define COMMAND_LINE_SIZE 2048
+#define KERNEL_IMAGE "/kernel"
+#define INITRD_IMAGE "/initrd.img"
+#define TEST_BINARY "/test_binary"
+
+static int mount_filesystems(void)
+{
+ if (mount("devtmpfs", "/dev", "devtmpfs", 0, NULL) < 0) {
+ fprintf(stderr, "INIT: Warning: Failed to mount devtmpfs\n");
+ return -1;
+ }
+
+ if (mount("debugfs", "/debugfs", "debugfs", 0, NULL) < 0) {
+ fprintf(stderr, "INIT: Failed to mount debugfs\n");
+ return -1;
+ }
+
+ if (mount("proc", "/proc", "proc", 0, NULL) < 0) {
+ fprintf(stderr, "INIT: Failed to mount proc\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static long kexec_file_load(int kernel_fd, int initrd_fd,
+ unsigned long cmdline_len, const char *cmdline,
+ unsigned long flags)
+{
+ return syscall(__NR_kexec_file_load, kernel_fd, initrd_fd, cmdline_len,
+ cmdline, flags);
+}
+
+static int kexec_load(void)
+{
+ char cmdline[COMMAND_LINE_SIZE];
+ int kernel_fd, initrd_fd, err;
+ ssize_t len;
+ int fd;
+
+ fd = open("/proc/cmdline", O_RDONLY);
+ if (fd < 0) {
+ fprintf(stderr, "INIT: Failed to read /proc/cmdline\n");
+
+ return -1;
+ }
+
+ len = read(fd, cmdline, sizeof(cmdline) - 1);
+ close(fd);
+ if (len < 0)
+ return -1;
+
+ cmdline[len] = 0;
+ if (len > 0 && cmdline[len - 1] == '\n')
+ cmdline[len - 1] = 0;
+
+ strncat(cmdline, " luo_stage=2", sizeof(cmdline) - strlen(cmdline) - 1);
+
+ kernel_fd = open(KERNEL_IMAGE, O_RDONLY);
+ if (kernel_fd < 0) {
+ fprintf(stderr, "INIT: Failed to open kernel image\n");
+ return -1;
+ }
+
+ initrd_fd = open(INITRD_IMAGE, O_RDONLY);
+ if (initrd_fd < 0) {
+ fprintf(stderr, "INIT: Failed to open initrd image\n");
+ close(kernel_fd);
+ return -1;
+ }
+
+ err = kexec_file_load(kernel_fd, initrd_fd, strlen(cmdline) + 1,
+ cmdline, 0);
+
+ close(initrd_fd);
+ close(kernel_fd);
+
+ return err ? : 0;
+}
+
+static int run_test(int stage)
+{
+ char stage_arg[32];
+ int status;
+ pid_t pid;
+
+ snprintf(stage_arg, sizeof(stage_arg), "--stage=%d", stage);
+
+ pid = fork();
+ if (pid < 0)
+ return -1;
+
+ if (!pid) {
+ static const char *const argv[] = {TEST_BINARY, stage_arg, NULL};
+
+ execve(TEST_BINARY, argv, NULL);
+ fprintf(stderr, "INIT: execve failed\n");
+ _exit(1);
+ }
+
+ waitpid(pid, &status, 0);
+
+ return (WIFEXITED(status) && WEXITSTATUS(status) == 0) ? 0 : -1;
+}
+
+static int is_stage_2(void)
+{
+ char cmdline[COMMAND_LINE_SIZE];
+ ssize_t len;
+ int fd;
+
+ fd = open("/proc/cmdline", O_RDONLY);
+ if (fd < 0)
+ return 0;
+
+ len = read(fd, cmdline, sizeof(cmdline) - 1);
+ close(fd);
+
+ if (len < 0)
+ return 0;
+
+ cmdline[len] = 0;
+
+ return !!strstr(cmdline, "luo_stage=2");
+}
+
+int main(int argc, char *argv[])
+{
+ int current_stage;
+
+ if (mount_filesystems())
+ goto err_reboot;
+
+ current_stage = is_stage_2() ? 2 : 1;
+
+ printf("INIT: Starting Stage %d\n", current_stage);
+
+ if (current_stage == 1 && kexec_load()) {
+ fprintf(stderr, "INIT: Failed to load kexec kernel\n");
+ goto err_reboot;
+ }
+
+ if (run_test(current_stage)) {
+ fprintf(stderr, "INIT: Test binary returned failure\n");
+ goto err_reboot;
+ }
+
+ printf("INIT: Stage %d completed successfully.\n", current_stage);
+ reboot(current_stage == 1 ? RB_KEXEC : RB_AUTOBOOT);
+
+ return 0;
+
+err_reboot:
+ reboot(RB_AUTOBOOT);
+
+ return -1;
+}
diff --git a/tools/testing/selftests/liveupdate/luo_test.sh b/tools/testing/selftests/liveupdate/luo_test.sh
new file mode 100755
index 000000000000..7d155956e2ff
--- /dev/null
+++ b/tools/testing/selftests/liveupdate/luo_test.sh
@@ -0,0 +1,296 @@
+#!/bin/bash
+# SPDX-License-Identifier: GPL-2.0
+
+set -ue
+
+CROSS_COMPILE="${CROSS_COMPILE:-""}"
+
+test_dir=$(realpath "$(dirname "$0")")
+kernel_dir=$(realpath "$test_dir/../../../..")
+
+workspace_dir=""
+headers_dir=""
+initrd=""
+KEEP_WORKSPACE=0
+
+source "$test_dir/../kselftest/ktap_helpers.sh"
+
+function get_arch_conf() {
+ local arch=$1
+ if [[ "$arch" == "arm64" ]]; then
+ QEMU_CMD="qemu-system-aarch64 -M virt -cpu max"
+ KERNEL_IMAGE="Image"
+ KERNEL_CMDLINE="console=ttyAMA0"
+ elif [[ "$arch" == "x86" ]]; then
+ QEMU_CMD="qemu-system-x86_64"
+ KERNEL_IMAGE="bzImage"
+ KERNEL_CMDLINE="console=ttyS0"
+ else
+ echo "Unsupported architecture: $arch"
+ exit 1
+ fi
+}
+
+function usage() {
+ cat <<EOF
+$0 [-d build_dir] [-j jobs] [-t target_arch] [-T test_name] [-w workspace_dir] [-k] [-h]
+Options:
+ -d) path to the kernel build directory (default: .luo_test_build.<arch>)
+ -j) number of jobs for compilation
+ -t) run test for target_arch (aarch64, x86_64)
+ -T) test name to run (default: luo_kexec_simple)
+ -w) custom workspace directory (default: creates temp dir)
+ -k) keep workspace directory after successful test
+ -h) display this help
+EOF
+}
+
+function cleanup() {
+ local exit_code=$?
+
+ if [ -z "$workspace_dir" ]; then
+ ktap_finished
+ return
+ fi
+
+ if [ $exit_code -ne 0 ]; then
+ echo "# Test failed (exit code $exit_code)."
+ echo "# Workspace preserved at: $workspace_dir"
+ elif [ "$KEEP_WORKSPACE" -eq 1 ]; then
+ echo "# Workspace preserved (user request) at: $workspace_dir"
+ else
+ rm -fr "$workspace_dir"
+ fi
+ ktap_finished
+}
+trap cleanup EXIT
+
+function skip() {
+ local msg=${1:-""}
+ ktap_test_skip "$msg"
+ exit "$KSFT_SKIP"
+}
+
+function fail() {
+ local msg=${1:-""}
+ ktap_test_fail "$msg"
+ exit "$KSFT_FAIL"
+}
+
+function detect_cross_compile() {
+ local target=$1
+ local host=$(uname -m)
+
+ if [ -n "$CROSS_COMPILE" ]; then
+ return
+ fi
+
+ [[ "$host" == "arm64" ]] && host="aarch64"
+ [[ "$target" == "arm64" ]] && target="aarch64"
+
+ if [[ "$host" == "$target" ]]; then
+ CROSS_COMPILE=""
+ return
+ fi
+
+ local candidate=""
+ case "$target" in
+ aarch64) candidate="aarch64-linux-gnu-" ;;
+ x86_64) candidate="x86_64-linux-gnu-" ;;
+ *) skip "Auto-detection for target '$target' not supported. Please set CROSS_COMPILE manually." ;;
+ esac
+
+ if command -v "${candidate}gcc" &> /dev/null; then
+ CROSS_COMPILE="$candidate"
+ else
+ skip "Compiler '${candidate}gcc' not found. Please install it (e.g., 'apt install gcc-aarch64-linux-gnu') or set CROSS_COMPILE."
+ fi
+}
+
+function build_kernel() {
+ local build_dir=$1
+ local make_cmd=$2
+ local kimage=$3
+ local target_arch=$4
+
+ local kconfig="$build_dir/.config"
+ local common_conf="$test_dir/config"
+ local arch_conf="$test_dir/config.$target_arch"
+
+ echo "# Building kernel in: $build_dir"
+ $make_cmd defconfig
+
+ local fragments=""
+ if [[ -f "$common_conf" ]]; then
+ fragments="$fragments $common_conf"
+ fi
+
+ if [[ -f "$arch_conf" ]]; then
+ fragments="$fragments $arch_conf"
+ fi
+
+ if [[ -n "$fragments" ]]; then
+ "$kernel_dir/scripts/kconfig/merge_config.sh" \
+ -Q -m -O "$build_dir" "$kconfig" $fragments >> /dev/null
+ fi
+
+ $make_cmd olddefconfig
+ $make_cmd "$kimage"
+ $make_cmd headers_install INSTALL_HDR_PATH="$headers_dir"
+}
+
+function mkinitrd() {
+ local build_dir=$1
+ local kernel_path=$2
+ local test_name=$3
+
+ # 1. Compile the test binary and the init process
+ "$CROSS_COMPILE"gcc -static -O2 \
+ -I "$headers_dir/include" \
+ -I "$test_dir" \
+ -o "$workspace_dir/test_binary" \
+ "$test_dir/$test_name.c" "$test_dir/luo_test_utils.c"
+
+ "$CROSS_COMPILE"gcc -s -static -Os -nostdinc -nostdlib \
+ -fno-asynchronous-unwind-tables -fno-ident \
+ -fno-stack-protector \
+ -I "$headers_dir/include" \
+ -I "$kernel_dir/tools/include/nolibc" \
+ -o "$workspace_dir/init" "$test_dir/init.c"
+
+ cat > "$workspace_dir/cpio_list_inner" <<EOF
+dir /dev 0755 0 0
+dir /proc 0755 0 0
+dir /debugfs 0755 0 0
+nod /dev/console 0600 0 0 c 5 1
+file /init $workspace_dir/init 0755 0 0
+file /test_binary $workspace_dir/test_binary 0755 0 0
+EOF
+
+ # Generate inner_initrd.cpio
+ "$build_dir/usr/gen_init_cpio" "$workspace_dir/cpio_list_inner" > "$workspace_dir/inner_initrd.cpio"
+
+ cat > "$workspace_dir/cpio_list" <<EOF
+dir /dev 0755 0 0
+dir /proc 0755 0 0
+dir /debugfs 0755 0 0
+nod /dev/console 0600 0 0 c 5 1
+file /init $workspace_dir/init 0755 0 0
+file /kernel $kernel_path 0644 0 0
+file /test_binary $workspace_dir/test_binary 0755 0 0
+file /initrd.img $workspace_dir/inner_initrd.cpio 0644 0 0
+EOF
+
+ # Generate the final initrd
+ "$build_dir/usr/gen_init_cpio" "$workspace_dir/cpio_list" > "$initrd"
+ local size=$(du -h "$initrd" | cut -f1)
+}
+
+function run_qemu() {
+ local qemu_cmd=$1
+ local cmdline=$2
+ local kernel_path=$3
+ local serial="$workspace_dir/qemu.serial"
+
+ local accel="-accel tcg"
+ local host_machine=$(uname -m)
+
+ [[ "$host_machine" == "arm64" ]] && host_machine="aarch64"
+ [[ "$host_machine" == "x86_64" ]] && host_machine="x86_64"
+
+ if [[ "$qemu_cmd" == *"$host_machine"* ]]; then
+ if [ -w /dev/kvm ]; then
+ accel="-accel kvm"
+ fi
+ fi
+
+ cmdline="$cmdline liveupdate=on panic=-1"
+
+ echo "# Serial Log: $serial"
+ timeout 30s $qemu_cmd -m 1G -smp 2 -no-reboot -nographic -nodefaults \
+ $accel \
+ -serial file:"$serial" \
+ -append "$cmdline" \
+ -kernel "$kernel_path" \
+ -initrd "$initrd"
+
+ local ret=$?
+
+ if [ $ret -eq 124 ]; then
+ fail "QEMU timed out"
+ fi
+
+ grep "TEST PASSED" "$serial" &> /dev/null || fail "Liveupdate failed. Check $serial for details."
+}
+
+function target_to_arch() {
+ local target=$1
+ case $target in
+ aarch64) echo "arm64" ;;
+ x86_64) echo "x86" ;;
+ *) skip "architecture $target is not supported"
+ esac
+}
+
+function main() {
+ local build_dir=""
+ local jobs=$(nproc)
+ local target="$(uname -m)"
+ local test_name="luo_kexec_simple"
+ local workspace_arg=""
+
+ set -o errtrace
+ trap skip ERR
+
+ while getopts 'hd:j:t:T:w:k' opt; do
+ case $opt in
+ d) build_dir="$OPTARG" ;;
+ j) jobs="$OPTARG" ;;
+ t) target="$OPTARG" ;;
+ T) test_name="$OPTARG" ;;
+ w) workspace_arg="$OPTARG" ;;
+ k) KEEP_WORKSPACE=1 ;;
+ h) usage; exit 0 ;;
+ *) echo "Unknown argument $opt"; usage; exit 1 ;;
+ esac
+ done
+
+ ktap_print_header
+ ktap_set_plan 1
+
+ if [ -n "$workspace_arg" ]; then
+ workspace_dir="$(realpath -m "$workspace_arg")"
+ mkdir -p "$workspace_dir"
+ else
+ workspace_dir=$(mktemp -d /tmp/luo-test.XXXXXXXX)
+ fi
+
+ echo "# Workspace created at: $workspace_dir"
+ headers_dir="$workspace_dir/usr"
+ initrd="$workspace_dir/initrd.cpio"
+
+ detect_cross_compile "$target"
+
+ local arch=$(target_to_arch "$target")
+
+ if [ -z "$build_dir" ]; then
+ build_dir="$kernel_dir/.luo_test_build.$arch"
+ fi
+
+ mkdir -p "$build_dir"
+ build_dir=$(realpath "$build_dir")
+ get_arch_conf "$arch"
+
+ local make_cmd="make -s ARCH=$arch CROSS_COMPILE=$CROSS_COMPILE -j$jobs"
+ local make_cmd_build="$make_cmd -C $kernel_dir O=$build_dir"
+
+ build_kernel "$build_dir" "$make_cmd_build" "$KERNEL_IMAGE" "$target"
+
+ local final_kernel="$build_dir/arch/$arch/boot/$KERNEL_IMAGE"
+ mkinitrd "$build_dir" "$final_kernel" "$test_name"
+
+ run_qemu "$QEMU_CMD" "$KERNEL_CMDLINE" "$final_kernel"
+ ktap_test_pass "$test_name succeeded"
+}
+
+main "$@"
diff --git a/tools/testing/selftests/liveupdate/run.sh b/tools/testing/selftests/liveupdate/run.sh
new file mode 100755
index 000000000000..3f6b29a26648
--- /dev/null
+++ b/tools/testing/selftests/liveupdate/run.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+# SPDX-License-Identifier: GPL-2.0
+
+OUTPUT_DIR="results_$(date +%Y%m%d_%H%M%S)"
+SCRIPT_DIR=$(dirname "$(realpath "$0")")
+TEST_RUNNER="$SCRIPT_DIR/luo_test.sh"
+
+TARGETS=("x86_64" "aarch64")
+
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+PASSED=()
+FAILED=()
+SKIPPED=()
+
+mkdir -p "$OUTPUT_DIR"
+
+TEST_NAMES=()
+while IFS= read -r file; do
+ TEST_NAMES+=("$(basename "$file" .c)")
+done < <(find "$SCRIPT_DIR" -maxdepth 1 -name "luo_*.c" ! -name "luo_test_utils.c")
+
+if [ ${#TEST_NAMES[@]} -eq 0 ]; then
+ echo "No tests found in $SCRIPT_DIR"
+ exit 1
+fi
+
+for arch in "${TARGETS[@]}"; do
+ for test_name in "${TEST_NAMES[@]}"; do
+ log_file="$OUTPUT_DIR/${arch}_${test_name}.log"
+ echo -n " -> $arch $test_name ... "
+
+ if "$TEST_RUNNER" -t "$arch" -T "$test_name" > "$log_file" 2>&1; then
+ echo -e "${GREEN}PASS${NC}"
+ PASSED+=("${arch}:${test_name}")
+ else
+ exit_code=$?
+ if [ $exit_code -eq 4 ]; then
+ echo -e "${YELLOW}SKIP${NC}"
+ SKIPPED+=("${arch}:${test_name}")
+ else
+ echo -e "${RED}FAIL${NC}"
+ FAILED+=("${arch}:${test_name}")
+ fi
+ fi
+ done
+ echo ""
+done
+
+echo "========================================="
+echo " TEST SUMMARY "
+echo "========================================="
+echo -e "PASSED: ${GREEN}${#PASSED[@]}${NC}"
+echo -e "FAILED: ${RED}${#FAILED[@]}${NC}"
+for fail in "${FAILED[@]}"; do
+ echo -e " - $fail"
+done
+echo -e "SKIPPED: ${YELLOW}${#SKIPPED[@]}${NC}"
+echo "Logs: $OUTPUT_DIR"
+
+if [ ${#FAILED[@]} -eq 0 ]; then
+ exit 0
+else
+ exit 1
+fi
--
2.52.0.rc2.455.g230fcf2819-googOn Sat, Nov 22, 2025 at 05:23:46PM -0500, Pasha Tatashin wrote:
> Subject: [PATCH v7 19/22] selftests/liveupdate: add test infrastructure and scripts
Maybe ^ end to end
> Add the testing infrastructure required to verify the liveupdate
> feature. This includes a custom init process, a test orchestration
> script, and a batch runner.
And say here that it's end to end test.
> The framework consists of:
>
> init.c:
> A lightweight init process that manages the kexec lifecycle.
> It mounts necessary filesystems, determines the current execution
> stage (1 or 2) via the kernel command line, and handles the
> kexec_file_load() sequence to transition between kernels.
>
> luo_test.sh:
> The primary KTAP-compliant test driver. It handles:
> - Kernel configuration merging and building.
> - Cross-compilation detection for x86_64 and arm64.
> - Generation of the initrd containing the test binary and init.
> - QEMU execution with automatic accelerator detection (KVM, HVF,
> or TCG).
>
> run.sh:
> A wrapper script to discover and execute all `luo_*.c`
> tests across supported architectures, providing a summary of
> pass/fail/skip results.
>
> Signed-off-by: Pasha Tatashin <pasha.tatashin@soleen.com>
> ---
> tools/testing/selftests/liveupdate/init.c | 174 ++++++++++
> .../testing/selftests/liveupdate/luo_test.sh | 296 ++++++++++++++++++
> tools/testing/selftests/liveupdate/run.sh | 68 ++++
> 3 files changed, 538 insertions(+)
> create mode 100644 tools/testing/selftests/liveupdate/init.c
> create mode 100755 tools/testing/selftests/liveupdate/luo_test.sh
> create mode 100755 tools/testing/selftests/liveupdate/run.sh
>
...
> +static int is_stage_2(void)
> +{
> + char cmdline[COMMAND_LINE_SIZE];
> + ssize_t len;
> + int fd;
> +
> + fd = open("/proc/cmdline", O_RDONLY);
> + if (fd < 0)
> + return 0;
> +
> + len = read(fd, cmdline, sizeof(cmdline) - 1);
> + close(fd);
> +
> + if (len < 0)
> + return 0;
Shouldn't we bail out of the test if read of command line failed?
> +
> + cmdline[len] = 0;
> +
> + return !!strstr(cmdline, "luo_stage=2");
> +}
> +
...
> +function cleanup() {
> + local exit_code=$?
> +
> + if [ -z "$workspace_dir" ]; then
> + ktap_finished
> + return
> + fi
> +
> + if [ $exit_code -ne 0 ]; then
> + echo "# Test failed (exit code $exit_code)."
> + echo "# Workspace preserved at: $workspace_dir"
> + elif [ "$KEEP_WORKSPACE" -eq 1 ]; then
> + echo "# Workspace preserved (user request) at: $workspace_dir"
> + else
> + rm -fr "$workspace_dir"
> + fi
> + ktap_finished
exit $exit_code
> +}
...
> +function build_kernel() {
> + local build_dir=$1
> + local make_cmd=$2
> + local kimage=$3
> + local target_arch=$4
> +
> + local kconfig="$build_dir/.config"
> + local common_conf="$test_dir/config"
> + local arch_conf="$test_dir/config.$target_arch"
> +
> + echo "# Building kernel in: $build_dir"
> + $make_cmd defconfig
> +
> + local fragments=""
> + if [[ -f "$common_conf" ]]; then
> + fragments="$fragments $common_conf"
> + fi
Without this CONFIG_LIVEUPDATE won't be set
> +
> + if [[ -f "$arch_conf" ]]; then
> + fragments="$fragments $arch_conf"
> + fi
> +
> + if [[ -n "$fragments" ]]; then
> + "$kernel_dir/scripts/kconfig/merge_config.sh" \
> + -Q -m -O "$build_dir" "$kconfig" $fragments >> /dev/null
> + fi
I believe you can just
cat $common_conf $fragments > $build_dir/.config
make olddefconfig
without running defconfig at the beginning
It will build faster, just make sure to add CONFIG_SERIAL_ to $arch_conf
> + $make_cmd olddefconfig
> + $make_cmd "$kimage"
> + $make_cmd headers_install INSTALL_HDR_PATH="$headers_dir"
> +}
> +
> +function mkinitrd() {
> + local build_dir=$1
> + local kernel_path=$2
> + local test_name=$3
> +
> + # 1. Compile the test binary and the init process
Didn't find 2. ;-)
Don't think we want the numbering here, plain comments are fine
> + "$CROSS_COMPILE"gcc -static -O2 \
> + -I "$headers_dir/include" \
> + -I "$test_dir" \
> + -o "$workspace_dir/test_binary" \
> + "$test_dir/$test_name.c" "$test_dir/luo_test_utils.c"
This will have hard time cross-compiling with -nolibc toolchains
> +
> + "$CROSS_COMPILE"gcc -s -static -Os -nostdinc -nostdlib \
> + -fno-asynchronous-unwind-tables -fno-ident \
> + -fno-stack-protector \
> + -I "$headers_dir/include" \
> + -I "$kernel_dir/tools/include/nolibc" \
> + -o "$workspace_dir/init" "$test_dir/init.c"
This failed for me with gcc 14.2.0 (Debian 14.2.0-19):
/home/mike/git/linux/tools/testing/selftests/liveupdate/init.c: In function ‘run_test’:
/home/mike/git/linux/tools/testing/selftests/liveupdate/init.c:111:65: error: initializer element is not constant
111 | static const char *const argv[] = {TEST_BINARY, stage_arg, NULL};
| ^~~~~~~~~
/home/mike/git/linux/tools/testing/selftests/liveupdate/init.c:111:65: note: (near initialization for ‘argv[1]’)
/home/mike/git/linux/tools/testing/selftests/liveupdate/init.c:113:37: error: passing argument 2 of ‘execve’ from incompatible pointer type [-Wincompatible-pointer-types]
113 | execve(TEST_BINARY, argv, NULL);
| ^~~~
| |
| const char * const*
In file included from /home/mike/git/linux/tools/testing/selftests/liveupdate/init.c:16:
/usr/include/unistd.h:572:52: note: expected ‘char * const*’ but argument is of type ‘const char * const*’
572 | extern int execve (const char *__path, char *const __argv[],
| ~~~~~~~~~~~~^~~~~~~~
> +
> + cat > "$workspace_dir/cpio_list_inner" <<EOF
> +dir /dev 0755 0 0
> +dir /proc 0755 0 0
> +dir /debugfs 0755 0 0
> +nod /dev/console 0600 0 0 c 5 1
Don't you need /dev/liveupdate node?
> +file /init $workspace_dir/init 0755 0 0
> +file /test_binary $workspace_dir/test_binary 0755 0 0
> +EOF
> +
> + # Generate inner_initrd.cpio
> + "$build_dir/usr/gen_init_cpio" "$workspace_dir/cpio_list_inner" > "$workspace_dir/inner_initrd.cpio"
> +
> + cat > "$workspace_dir/cpio_list" <<EOF
> +dir /dev 0755 0 0
> +dir /proc 0755 0 0
> +dir /debugfs 0755 0 0
> +nod /dev/console 0600 0 0 c 5 1
And here as well.
> +file /init $workspace_dir/init 0755 0 0
> +file /kernel $kernel_path 0644 0 0
> +file /test_binary $workspace_dir/test_binary 0755 0 0
> +file /initrd.img $workspace_dir/inner_initrd.cpio 0644 0 0
> +EOF
> +
> + # Generate the final initrd
> + "$build_dir/usr/gen_init_cpio" "$workspace_dir/cpio_list" > "$initrd"
> + local size=$(du -h "$initrd" | cut -f1)
> +}
> +
> +function run_qemu() {
> + local qemu_cmd=$1
> + local cmdline=$2
> + local kernel_path=$3
> + local serial="$workspace_dir/qemu.serial"
> +
> + local accel="-accel tcg"
> + local host_machine=$(uname -m)
> +
> + [[ "$host_machine" == "arm64" ]] && host_machine="aarch64"
> + [[ "$host_machine" == "x86_64" ]] && host_machine="x86_64"
> +
> + if [[ "$qemu_cmd" == *"$host_machine"* ]]; then
> + if [ -w /dev/kvm ]; then
> + accel="-accel kvm"
Just pass both kvm and tcg and let qemu complain.
> + fi
> + fi
> +
> + cmdline="$cmdline liveupdate=on panic=-1"
> +
> + echo "# Serial Log: $serial"
> + timeout 30s $qemu_cmd -m 1G -smp 2 -no-reboot -nographic -nodefaults \
> + $accel \
> + -serial file:"$serial" \
> + -append "$cmdline" \
> + -kernel "$kernel_path" \
> + -initrd "$initrd"
> +
> + local ret=$?
> +
> + if [ $ret -eq 124 ]; then
> + fail "QEMU timed out"
> + fi
> +
> + grep "TEST PASSED" "$serial" &> /dev/null || fail "Liveupdate failed. Check $serial for details."
> +}
--
Sincerely yours,
Mike.
On Mon, Nov 24, 2025 at 2:54 AM Mike Rapoport <rppt@kernel.org> wrote:
>
> On Sat, Nov 22, 2025 at 05:23:46PM -0500, Pasha Tatashin wrote:
> > Subject: [PATCH v7 19/22] selftests/liveupdate: add test infrastructure and scripts
>
> Maybe ^ end to end
Done.
>
> > Add the testing infrastructure required to verify the liveupdate
> > feature. This includes a custom init process, a test orchestration
> > script, and a batch runner.
>
> And say here that it's end to end test.
Done
> > +static int is_stage_2(void)
> > +{
> > + char cmdline[COMMAND_LINE_SIZE];
> > + ssize_t len;
> > + int fd;
> > +
> > + fd = open("/proc/cmdline", O_RDONLY);
> > + if (fd < 0)
> > + return 0;
> > +
> > + len = read(fd, cmdline, sizeof(cmdline) - 1);
> > + close(fd);
> > +
> > + if (len < 0)
> > + return 0;
>
> Shouldn't we bail out of the test if read of command line failed?
Sure, done.
> > +function cleanup() {
> > + local exit_code=$?
> > +
> > + if [ -z "$workspace_dir" ]; then
> > + ktap_finished
> > + return
> > + fi
> > +
> > + if [ $exit_code -ne 0 ]; then
> > + echo "# Test failed (exit code $exit_code)."
> > + echo "# Workspace preserved at: $workspace_dir"
> > + elif [ "$KEEP_WORKSPACE" -eq 1 ]; then
> > + echo "# Workspace preserved (user request) at: $workspace_dir"
> > + else
> > + rm -fr "$workspace_dir"
> > + fi
> > + ktap_finished
>
> exit $exit_code
Done
> > +function build_kernel() {
> > + local build_dir=$1
> > + local make_cmd=$2
> > + local kimage=$3
> > + local target_arch=$4
> > +
> > + local kconfig="$build_dir/.config"
> > + local common_conf="$test_dir/config"
> > + local arch_conf="$test_dir/config.$target_arch"
> > +
> > + echo "# Building kernel in: $build_dir"
> > + $make_cmd defconfig
> > +
> > + local fragments=""
> > + if [[ -f "$common_conf" ]]; then
> > + fragments="$fragments $common_conf"
> > + fi
>
> Without this CONFIG_LIVEUPDATE won't be set
> > +
> > + if [[ -f "$arch_conf" ]]; then
> > + fragments="$fragments $arch_conf"
> > + fi
> > +
> > + if [[ -n "$fragments" ]]; then
> > + "$kernel_dir/scripts/kconfig/merge_config.sh" \
> > + -Q -m -O "$build_dir" "$kconfig" $fragments >> /dev/null
> > + fi
>
> I believe you can just
>
> cat $common_conf $fragments > $build_dir/.config
> make olddefconfig
>
> without running defconfig at the beginning
> It will build faster, just make sure to add CONFIG_SERIAL_ to $arch_conf
I will look into that, so how performance really changes, I liked
using merge_config.sh as it does not print warnings.
>
> > + $make_cmd olddefconfig
> > + $make_cmd "$kimage"
> > + $make_cmd headers_install INSTALL_HDR_PATH="$headers_dir"
> > +}
> > +
> > +function mkinitrd() {
> > + local build_dir=$1
> > + local kernel_path=$2
> > + local test_name=$3
> > +
> > + # 1. Compile the test binary and the init process
>
> Didn't find 2. ;-)
> Don't think we want the numbering here, plain comments are fine
Updated comment.
>
> > + "$CROSS_COMPILE"gcc -static -O2 \
> > + -I "$headers_dir/include" \
> > + -I "$test_dir" \
> > + -o "$workspace_dir/test_binary" \
> > + "$test_dir/$test_name.c" "$test_dir/luo_test_utils.c"
>
> This will have hard time cross-compiling with -nolibc toolchains
Hm, it works for me, I am not sure with nolibc cross compiler, am I
missing something?
>
> > +
> > + "$CROSS_COMPILE"gcc -s -static -Os -nostdinc -nostdlib \
> > + -fno-asynchronous-unwind-tables -fno-ident \
> > + -fno-stack-protector \
> > + -I "$headers_dir/include" \
> > + -I "$kernel_dir/tools/include/nolibc" \
> > + -o "$workspace_dir/init" "$test_dir/init.c"
>
> This failed for me with gcc 14.2.0 (Debian 14.2.0-19):
Updated, removed the extra const, and static.
>
> /home/mike/git/linux/tools/testing/selftests/liveupdate/init.c: In function ‘run_test’:
> /home/mike/git/linux/tools/testing/selftests/liveupdate/init.c:111:65: error: initializer element is not constant
> 111 | static const char *const argv[] = {TEST_BINARY, stage_arg, NULL};
> | ^~~~~~~~~
>
> /home/mike/git/linux/tools/testing/selftests/liveupdate/init.c:111:65: note: (near initialization for ‘argv[1]’)
> /home/mike/git/linux/tools/testing/selftests/liveupdate/init.c:113:37: error: passing argument 2 of ‘execve’ from incompatible pointer type [-Wincompatible-pointer-types]
> 113 | execve(TEST_BINARY, argv, NULL);
> | ^~~~
> | |
> | const char * const*
> In file included from /home/mike/git/linux/tools/testing/selftests/liveupdate/init.c:16:
> /usr/include/unistd.h:572:52: note: expected ‘char * const*’ but argument is of type ‘const char * const*’
> 572 | extern int execve (const char *__path, char *const __argv[],
> | ~~~~~~~~~~~~^~~~~~~~
>
> > +
> > + cat > "$workspace_dir/cpio_list_inner" <<EOF
> > +dir /dev 0755 0 0
> > +dir /proc 0755 0 0
> > +dir /debugfs 0755 0 0
> > +nod /dev/console 0600 0 0 c 5 1
>
> Don't you need /dev/liveupdate node?
That should be created by the kernel itself.
>
> > +file /init $workspace_dir/init 0755 0 0
> > +file /test_binary $workspace_dir/test_binary 0755 0 0
> > +EOF
> > +
> > + # Generate inner_initrd.cpio
> > + "$build_dir/usr/gen_init_cpio" "$workspace_dir/cpio_list_inner" > "$workspace_dir/inner_initrd.cpio"
> > +
> > + cat > "$workspace_dir/cpio_list" <<EOF
> > +dir /dev 0755 0 0
> > +dir /proc 0755 0 0
> > +dir /debugfs 0755 0 0
> > +nod /dev/console 0600 0 0 c 5 1
>
> And here as well.
Not needed.
>
> > +file /init $workspace_dir/init 0755 0 0
> > +file /kernel $kernel_path 0644 0 0
> > +file /test_binary $workspace_dir/test_binary 0755 0 0
> > +file /initrd.img $workspace_dir/inner_initrd.cpio 0644 0 0
> > +EOF
> > +
> > + # Generate the final initrd
> > + "$build_dir/usr/gen_init_cpio" "$workspace_dir/cpio_list" > "$initrd"
> > + local size=$(du -h "$initrd" | cut -f1)
> > +}
> > +
> > +function run_qemu() {
> > + local qemu_cmd=$1
> > + local cmdline=$2
> > + local kernel_path=$3
> > + local serial="$workspace_dir/qemu.serial"
> > +
> > + local accel="-accel tcg"
> > + local host_machine=$(uname -m)
> > +
> > + [[ "$host_machine" == "arm64" ]] && host_machine="aarch64"
> > + [[ "$host_machine" == "x86_64" ]] && host_machine="x86_64"
> > +
> > + if [[ "$qemu_cmd" == *"$host_machine"* ]]; then
> > + if [ -w /dev/kvm ]; then
> > + accel="-accel kvm"
>
> Just pass both kvm and tcg and let qemu complain.
I hated those warnings, this is why I added this "if" in the first place :-)
Thank you for your reviews, I am going to send this patch separately
from this series, so let's continue the discussion there.
Pasha
© 2016 - 2025 Red Hat, Inc.