c4bbe83d27
The modules are being moved from lib/livepatch to
tools/testing/selftests/livepatch/test_modules.
This code moving will allow writing more complex tests, like for example an
userspace C code that will call a livepatched kernel function.
The modules are now built as out-of-tree
modules, but being part of the kernel source means they will be maintained.
Another advantage of the code moving is to be able to easily change,
debug and rebuild the tests by running make on the selftests/livepatch
directory, which is not currently possible since the modules on
lib/livepatch are build and installed using the "modules" target.
The current approach also keeps the ability to execute the tests manually
by executing the scripts inside selftests/livepatch directory, as it's
currently supported. If the modules are modified, they needed to be
rebuilt before running the scripts though.
The modules are built before running the selftests when using the
kselftest invocations:
make kselftest TARGETS=livepatch
or
make -C tools/testing/selftests/livepatch run_tests
Having the modules being built as out-of-modules requires changing the
currently used 'modprobe' by 'insmod' and adapt the test scripts that
check for the kernel message buffer.
Now it is possible to only compile the modules by running:
make -C tools/testing/selftests/livepatch/
This way the test modules and other test program can be built in order
to be packaged if so desired.
As there aren't any modules being built on lib/livepatch, remove the
TEST_LIVEPATCH Kconfig and it's references.
Note: "make gen_tar" packages the pre-built binaries into the tarball.
It means that it will store the test modules pre-built for
the kernel running on the build host.
Note that these modules need not binary compatible with
the kernel built from the same sources. But the same
is true for other packaged selftest binaries.
The entire kernel sources are needed for rebuilding
the selftests on another system.
Reviewed-by: Joe Lawrence <joe.lawrence@redhat.com>
Reviewed-by: Petr Mladek <pmladek@suse.com>
Signed-off-by: Marcos Paulo de Souza <mpdesouza@suse.com>
Acked-by: Alexander Gordeev <agordeev@linux.ibm.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
553 lines
23 KiB
Bash
Executable file
553 lines
23 KiB
Bash
Executable file
#!/bin/bash
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
# Copyright (C) 2018 Joe Lawrence <joe.lawrence@redhat.com>
|
|
|
|
. $(dirname $0)/functions.sh
|
|
|
|
MOD_LIVEPATCH=test_klp_callbacks_demo
|
|
MOD_LIVEPATCH2=test_klp_callbacks_demo2
|
|
MOD_TARGET=test_klp_callbacks_mod
|
|
MOD_TARGET_BUSY=test_klp_callbacks_busy
|
|
|
|
setup_config
|
|
|
|
|
|
# Test a combination of loading a kernel module and a livepatch that
|
|
# patches a function in the first module. Load the target module
|
|
# before the livepatch module. Unload them in the same order.
|
|
#
|
|
# - On livepatch enable, before the livepatch transition starts,
|
|
# pre-patch callbacks are executed for vmlinux and $MOD_TARGET (those
|
|
# klp_objects currently loaded). After klp_objects are patched
|
|
# according to the klp_patch, their post-patch callbacks run and the
|
|
# transition completes.
|
|
#
|
|
# - Similarly, on livepatch disable, pre-patch callbacks run before the
|
|
# unpatching transition starts. klp_objects are reverted, post-patch
|
|
# callbacks execute and the transition completes.
|
|
|
|
start_test "target module before livepatch"
|
|
|
|
load_mod $MOD_TARGET
|
|
load_lp $MOD_LIVEPATCH
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH
|
|
unload_mod $MOD_TARGET
|
|
|
|
check_result "% insmod test_modules/$MOD_TARGET.ko
|
|
$MOD_TARGET: ${MOD_TARGET}_init
|
|
% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
$MOD_LIVEPATCH: post_patch_callback: $MOD_TARGET -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: vmlinux
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
$MOD_LIVEPATCH: post_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH
|
|
% rmmod $MOD_TARGET
|
|
$MOD_TARGET: ${MOD_TARGET}_exit"
|
|
|
|
|
|
# This test is similar to the previous test, but (un)load the livepatch
|
|
# module before the target kernel module. This tests the livepatch
|
|
# core's module_coming handler.
|
|
#
|
|
# - On livepatch enable, only pre/post-patch callbacks are executed for
|
|
# currently loaded klp_objects, in this case, vmlinux.
|
|
#
|
|
# - When a targeted module is subsequently loaded, only its
|
|
# pre/post-patch callbacks are executed.
|
|
#
|
|
# - On livepatch disable, all currently loaded klp_objects' (vmlinux and
|
|
# $MOD_TARGET) pre/post-unpatch callbacks are executed.
|
|
|
|
start_test "module_coming notifier"
|
|
|
|
load_lp $MOD_LIVEPATCH
|
|
load_mod $MOD_TARGET
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH
|
|
unload_mod $MOD_TARGET
|
|
|
|
check_result "% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% insmod test_modules/$MOD_TARGET.ko
|
|
livepatch: applying patch '$MOD_LIVEPATCH' to loading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET -> [MODULE_STATE_COMING] Full formed, running module_init
|
|
$MOD_LIVEPATCH: post_patch_callback: $MOD_TARGET -> [MODULE_STATE_COMING] Full formed, running module_init
|
|
$MOD_TARGET: ${MOD_TARGET}_init
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: vmlinux
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
$MOD_LIVEPATCH: post_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH
|
|
% rmmod $MOD_TARGET
|
|
$MOD_TARGET: ${MOD_TARGET}_exit"
|
|
|
|
|
|
# Test loading the livepatch after a targeted kernel module, then unload
|
|
# the kernel module before disabling the livepatch. This tests the
|
|
# livepatch core's module_going handler.
|
|
#
|
|
# - First load a target module, then the livepatch.
|
|
#
|
|
# - When a target module is unloaded, the livepatch is only reverted
|
|
# from that klp_object ($MOD_TARGET). As such, only its pre and
|
|
# post-unpatch callbacks are executed when this occurs.
|
|
#
|
|
# - When the livepatch is disabled, pre and post-unpatch callbacks are
|
|
# run for the remaining klp_object, vmlinux.
|
|
|
|
start_test "module_going notifier"
|
|
|
|
load_mod $MOD_TARGET
|
|
load_lp $MOD_LIVEPATCH
|
|
unload_mod $MOD_TARGET
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH
|
|
|
|
check_result "% insmod test_modules/$MOD_TARGET.ko
|
|
$MOD_TARGET: ${MOD_TARGET}_init
|
|
% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
$MOD_LIVEPATCH: post_patch_callback: $MOD_TARGET -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% rmmod $MOD_TARGET
|
|
$MOD_TARGET: ${MOD_TARGET}_exit
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_GOING] Going away
|
|
livepatch: reverting patch '$MOD_LIVEPATCH' on unloading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: post_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_GOING] Going away
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH"
|
|
|
|
|
|
# This test is similar to the previous test, however the livepatch is
|
|
# loaded first. This tests the livepatch core's module_coming and
|
|
# module_going handlers.
|
|
#
|
|
# - First load the livepatch.
|
|
#
|
|
# - When a targeted kernel module is subsequently loaded, only its
|
|
# pre/post-patch callbacks are executed.
|
|
#
|
|
# - When the target module is unloaded, the livepatch is only reverted
|
|
# from the $MOD_TARGET klp_object. As such, only pre and
|
|
# post-unpatch callbacks are executed when this occurs.
|
|
|
|
start_test "module_coming and module_going notifiers"
|
|
|
|
load_lp $MOD_LIVEPATCH
|
|
load_mod $MOD_TARGET
|
|
unload_mod $MOD_TARGET
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH
|
|
|
|
check_result "% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% insmod test_modules/$MOD_TARGET.ko
|
|
livepatch: applying patch '$MOD_LIVEPATCH' to loading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET -> [MODULE_STATE_COMING] Full formed, running module_init
|
|
$MOD_LIVEPATCH: post_patch_callback: $MOD_TARGET -> [MODULE_STATE_COMING] Full formed, running module_init
|
|
$MOD_TARGET: ${MOD_TARGET}_init
|
|
% rmmod $MOD_TARGET
|
|
$MOD_TARGET: ${MOD_TARGET}_exit
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_GOING] Going away
|
|
livepatch: reverting patch '$MOD_LIVEPATCH' on unloading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: post_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_GOING] Going away
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH"
|
|
|
|
|
|
# A simple test of loading a livepatch without one of its patch target
|
|
# klp_objects ever loaded ($MOD_TARGET).
|
|
#
|
|
# - Load the livepatch.
|
|
#
|
|
# - As expected, only pre/post-(un)patch handlers are executed for
|
|
# vmlinux.
|
|
|
|
start_test "target module not present"
|
|
|
|
load_lp $MOD_LIVEPATCH
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH
|
|
|
|
check_result "% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH"
|
|
|
|
|
|
# Test a scenario where a vmlinux pre-patch callback returns a non-zero
|
|
# status (ie, failure).
|
|
#
|
|
# - First load a target module.
|
|
#
|
|
# - Load the livepatch module, setting its 'pre_patch_ret' value to -19
|
|
# (-ENODEV). When its vmlinux pre-patch callback executes, this
|
|
# status code will propagate back to the module-loading subsystem.
|
|
# The result is that the insmod command refuses to load the livepatch
|
|
# module.
|
|
|
|
start_test "pre-patch callback -ENODEV"
|
|
|
|
load_mod $MOD_TARGET
|
|
load_failing_mod $MOD_LIVEPATCH pre_patch_ret=-19
|
|
unload_mod $MOD_TARGET
|
|
|
|
check_result "% insmod test_modules/$MOD_TARGET.ko
|
|
$MOD_TARGET: ${MOD_TARGET}_init
|
|
% insmod test_modules/$MOD_LIVEPATCH.ko pre_patch_ret=-19
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
test_klp_callbacks_demo: pre_patch_callback: vmlinux
|
|
livepatch: pre-patch callback failed for object 'vmlinux'
|
|
livepatch: failed to enable patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': canceling patching transition, going to unpatch
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
insmod: ERROR: could not insert module test_modules/$MOD_LIVEPATCH.ko: No such device
|
|
% rmmod $MOD_TARGET
|
|
$MOD_TARGET: ${MOD_TARGET}_exit"
|
|
|
|
|
|
# Similar to the previous test, setup a livepatch such that its vmlinux
|
|
# pre-patch callback returns success. However, when a targeted kernel
|
|
# module is later loaded, have the livepatch return a failing status
|
|
# code.
|
|
#
|
|
# - Load the livepatch, vmlinux pre-patch callback succeeds.
|
|
#
|
|
# - Set a trap so subsequent pre-patch callbacks to this livepatch will
|
|
# return -ENODEV.
|
|
#
|
|
# - The livepatch pre-patch callback for subsequently loaded target
|
|
# modules will return failure, so the module loader refuses to load
|
|
# the kernel module. No post-patch or pre/post-unpatch callbacks are
|
|
# executed for this klp_object.
|
|
#
|
|
# - Pre/post-unpatch callbacks are run for the vmlinux klp_object.
|
|
|
|
start_test "module_coming + pre-patch callback -ENODEV"
|
|
|
|
load_lp $MOD_LIVEPATCH
|
|
set_pre_patch_ret $MOD_LIVEPATCH -19
|
|
load_failing_mod $MOD_TARGET
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH
|
|
|
|
check_result "% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% echo -19 > /sys/module/$MOD_LIVEPATCH/parameters/pre_patch_ret
|
|
% insmod test_modules/$MOD_TARGET.ko
|
|
livepatch: applying patch '$MOD_LIVEPATCH' to loading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET -> [MODULE_STATE_COMING] Full formed, running module_init
|
|
livepatch: pre-patch callback failed for object '$MOD_TARGET'
|
|
livepatch: patch '$MOD_LIVEPATCH' failed for module '$MOD_TARGET', refusing to load module '$MOD_TARGET'
|
|
insmod: ERROR: could not insert module test_modules/$MOD_TARGET.ko: No such device
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH"
|
|
|
|
|
|
# Test loading multiple targeted kernel modules. This test-case is
|
|
# mainly for comparing with the next test-case.
|
|
#
|
|
# - Load a target "busy" kernel module which kicks off a worker function
|
|
# that immediately exits.
|
|
#
|
|
# - Proceed with loading the livepatch and another ordinary target
|
|
# module. Post-patch callbacks are executed and the transition
|
|
# completes quickly.
|
|
|
|
start_test "multiple target modules"
|
|
|
|
load_mod $MOD_TARGET_BUSY block_transition=N
|
|
load_lp $MOD_LIVEPATCH
|
|
load_mod $MOD_TARGET
|
|
unload_mod $MOD_TARGET
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH
|
|
unload_mod $MOD_TARGET_BUSY
|
|
|
|
check_result "% insmod test_modules/$MOD_TARGET_BUSY.ko block_transition=N
|
|
$MOD_TARGET_BUSY: ${MOD_TARGET_BUSY}_init
|
|
$MOD_TARGET_BUSY: busymod_work_func enter
|
|
$MOD_TARGET_BUSY: busymod_work_func exit
|
|
% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET_BUSY -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
$MOD_LIVEPATCH: post_patch_callback: $MOD_TARGET_BUSY -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% insmod test_modules/$MOD_TARGET.ko
|
|
livepatch: applying patch '$MOD_LIVEPATCH' to loading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET -> [MODULE_STATE_COMING] Full formed, running module_init
|
|
$MOD_LIVEPATCH: post_patch_callback: $MOD_TARGET -> [MODULE_STATE_COMING] Full formed, running module_init
|
|
$MOD_TARGET: ${MOD_TARGET}_init
|
|
% rmmod $MOD_TARGET
|
|
$MOD_TARGET: ${MOD_TARGET}_exit
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_GOING] Going away
|
|
livepatch: reverting patch '$MOD_LIVEPATCH' on unloading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: post_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_GOING] Going away
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: vmlinux
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: $MOD_TARGET_BUSY -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
$MOD_LIVEPATCH: post_unpatch_callback: $MOD_TARGET_BUSY -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH
|
|
% rmmod $MOD_TARGET_BUSY
|
|
$MOD_TARGET_BUSY: ${MOD_TARGET_BUSY}_exit"
|
|
|
|
|
|
# A similar test as the previous one, but force the "busy" kernel module
|
|
# to block the livepatch transition.
|
|
#
|
|
# The livepatching core will refuse to patch a task that is currently
|
|
# executing a to-be-patched function -- the consistency model stalls the
|
|
# current patch transition until this safety-check is met. Test a
|
|
# scenario where one of a livepatch's target klp_objects sits on such a
|
|
# function for a long time. Meanwhile, load and unload other target
|
|
# kernel modules while the livepatch transition is in progress.
|
|
#
|
|
# - Load the "busy" kernel module, this time make its work function loop
|
|
#
|
|
# - Meanwhile, the livepatch is loaded. Notice that the patch
|
|
# transition does not complete as the targeted "busy" module is
|
|
# sitting on a to-be-patched function.
|
|
#
|
|
# - Load a second target module (this one is an ordinary idle kernel
|
|
# module). Note that *no* post-patch callbacks will be executed while
|
|
# the livepatch is still in transition.
|
|
#
|
|
# - Request an unload of the simple kernel module. The patch is still
|
|
# transitioning, so its pre-unpatch callbacks are skipped.
|
|
#
|
|
# - Finally the livepatch is disabled. Since none of the patch's
|
|
# klp_object's post-patch callbacks executed, the remaining
|
|
# klp_object's pre-unpatch callbacks are skipped.
|
|
|
|
start_test "busy target module"
|
|
|
|
load_mod $MOD_TARGET_BUSY block_transition=Y
|
|
load_lp_nowait $MOD_LIVEPATCH
|
|
|
|
# Wait until the livepatch reports in-transition state, i.e. that it's
|
|
# stalled on $MOD_TARGET_BUSY::busymod_work_func()
|
|
loop_until 'grep -q '^1$' /sys/kernel/livepatch/$MOD_LIVEPATCH/transition' ||
|
|
die "failed to stall transition"
|
|
|
|
load_mod $MOD_TARGET
|
|
unload_mod $MOD_TARGET
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH
|
|
unload_mod $MOD_TARGET_BUSY
|
|
|
|
check_result "% insmod test_modules/$MOD_TARGET_BUSY.ko block_transition=Y
|
|
$MOD_TARGET_BUSY: ${MOD_TARGET_BUSY}_init
|
|
$MOD_TARGET_BUSY: busymod_work_func enter
|
|
% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET_BUSY -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
% insmod test_modules/$MOD_TARGET.ko
|
|
livepatch: applying patch '$MOD_LIVEPATCH' to loading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: pre_patch_callback: $MOD_TARGET -> [MODULE_STATE_COMING] Full formed, running module_init
|
|
$MOD_TARGET: ${MOD_TARGET}_init
|
|
% rmmod $MOD_TARGET
|
|
$MOD_TARGET: ${MOD_TARGET}_exit
|
|
livepatch: reverting patch '$MOD_LIVEPATCH' on unloading module '$MOD_TARGET'
|
|
$MOD_LIVEPATCH: post_unpatch_callback: $MOD_TARGET -> [MODULE_STATE_GOING] Going away
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': reversing transition from patching to unpatching
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
$MOD_LIVEPATCH: post_unpatch_callback: $MOD_TARGET_BUSY -> [MODULE_STATE_LIVE] Normal state
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH
|
|
% rmmod $MOD_TARGET_BUSY
|
|
$MOD_TARGET_BUSY: busymod_work_func exit
|
|
$MOD_TARGET_BUSY: ${MOD_TARGET_BUSY}_exit"
|
|
|
|
|
|
# Test loading multiple livepatches. This test-case is mainly for comparing
|
|
# with the next test-case.
|
|
#
|
|
# - Load and unload two livepatches, pre and post (un)patch callbacks
|
|
# execute as each patch progresses through its (un)patching
|
|
# transition.
|
|
|
|
start_test "multiple livepatches"
|
|
|
|
load_lp $MOD_LIVEPATCH
|
|
load_lp $MOD_LIVEPATCH2
|
|
disable_lp $MOD_LIVEPATCH2
|
|
disable_lp $MOD_LIVEPATCH
|
|
unload_lp $MOD_LIVEPATCH2
|
|
unload_lp $MOD_LIVEPATCH
|
|
|
|
check_result "% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% insmod test_modules/$MOD_LIVEPATCH2.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH2'
|
|
livepatch: '$MOD_LIVEPATCH2': initializing patching transition
|
|
$MOD_LIVEPATCH2: pre_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH2': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH2': completing patching transition
|
|
$MOD_LIVEPATCH2: post_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH2': patching complete
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH2/enabled
|
|
livepatch: '$MOD_LIVEPATCH2': initializing unpatching transition
|
|
$MOD_LIVEPATCH2: pre_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH2': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH2': completing unpatching transition
|
|
$MOD_LIVEPATCH2: post_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH2': unpatching complete
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
|
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
|
$MOD_LIVEPATCH: pre_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
|
$MOD_LIVEPATCH: post_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH2
|
|
% rmmod $MOD_LIVEPATCH"
|
|
|
|
|
|
# Load multiple livepatches, but the second as an 'atomic-replace'
|
|
# patch. When the latter loads, the original livepatch should be
|
|
# disabled and *none* of its pre/post-unpatch callbacks executed. On
|
|
# the other hand, when the atomic-replace livepatch is disabled, its
|
|
# pre/post-unpatch callbacks *should* be executed.
|
|
#
|
|
# - Load and unload two livepatches, the second of which has its
|
|
# .replace flag set true.
|
|
#
|
|
# - Pre and post patch callbacks are executed for both livepatches.
|
|
#
|
|
# - Once the atomic replace module is loaded, only its pre and post
|
|
# unpatch callbacks are executed.
|
|
|
|
start_test "atomic replace"
|
|
|
|
load_lp $MOD_LIVEPATCH
|
|
load_lp $MOD_LIVEPATCH2 replace=1
|
|
disable_lp $MOD_LIVEPATCH2
|
|
unload_lp $MOD_LIVEPATCH2
|
|
unload_lp $MOD_LIVEPATCH
|
|
|
|
check_result "% insmod test_modules/$MOD_LIVEPATCH.ko
|
|
livepatch: enabling patch '$MOD_LIVEPATCH'
|
|
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
|
$MOD_LIVEPATCH: pre_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
|
$MOD_LIVEPATCH: post_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH': patching complete
|
|
% insmod test_modules/$MOD_LIVEPATCH2.ko replace=1
|
|
livepatch: enabling patch '$MOD_LIVEPATCH2'
|
|
livepatch: '$MOD_LIVEPATCH2': initializing patching transition
|
|
$MOD_LIVEPATCH2: pre_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH2': starting patching transition
|
|
livepatch: '$MOD_LIVEPATCH2': completing patching transition
|
|
$MOD_LIVEPATCH2: post_patch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH2': patching complete
|
|
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH2/enabled
|
|
livepatch: '$MOD_LIVEPATCH2': initializing unpatching transition
|
|
$MOD_LIVEPATCH2: pre_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH2': starting unpatching transition
|
|
livepatch: '$MOD_LIVEPATCH2': completing unpatching transition
|
|
$MOD_LIVEPATCH2: post_unpatch_callback: vmlinux
|
|
livepatch: '$MOD_LIVEPATCH2': unpatching complete
|
|
% rmmod $MOD_LIVEPATCH2
|
|
% rmmod $MOD_LIVEPATCH"
|
|
|
|
|
|
exit 0
|