selftests/livepatch: introduce tests
Add a few livepatch modules and simple target modules that the included regression suite can run tests against: - basic livepatching (multiple patches, atomic replace) - pre/post (un)patch callbacks - shadow variable API Signed-off-by: Joe Lawrence <joe.lawrence@redhat.com> Signed-off-by: Petr Mladek <pmladek@suse.com> Tested-by: Miroslav Benes <mbenes@suse.cz> Tested-by: Alice Ferrazzi <alice.ferrazzi@gmail.com> Acked-by: Joe Lawrence <joe.lawrence@redhat.com> Acked-by: Josh Poimboeuf <jpoimboe@redhat.com> Signed-off-by: Jiri Kosina <jkosina@suse.cz>
This commit is contained in:
Joe Lawrence
committed by
Jiri Kosina
Jiri Kosina
parent
d67a537209
commit
a2818ee4dc
@@ -0,0 +1,8 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
TEST_GEN_PROGS := \
|
||||
test-livepatch.sh \
|
||||
test-callbacks.sh \
|
||||
test-shadow-vars.sh
|
||||
|
||||
include ../lib.mk
|
||||
@@ -0,0 +1,43 @@
|
||||
====================
|
||||
Livepatch Self Tests
|
||||
====================
|
||||
|
||||
This is a small set of sanity tests for the kernel livepatching.
|
||||
|
||||
The test suite loads and unloads several test kernel modules to verify
|
||||
livepatch behavior. Debug information is logged to the kernel's message
|
||||
buffer and parsed for expected messages. (Note: the tests will clear
|
||||
the message buffer between individual tests.)
|
||||
|
||||
|
||||
Config
|
||||
------
|
||||
|
||||
Set these config options and their prerequisites:
|
||||
|
||||
CONFIG_LIVEPATCH=y
|
||||
CONFIG_TEST_LIVEPATCH=m
|
||||
|
||||
|
||||
Running the tests
|
||||
-----------------
|
||||
|
||||
Test kernel modules are built as part of lib/ (make modules) and need to
|
||||
be installed (make modules_install) as the test scripts will modprobe
|
||||
them.
|
||||
|
||||
To run the livepatch selftests, from the top of the kernel source tree:
|
||||
|
||||
% make -C tools/testing/selftests TARGETS=livepatch run_tests
|
||||
|
||||
|
||||
Adding tests
|
||||
------------
|
||||
|
||||
See the common functions.sh file for the existing collection of utility
|
||||
functions, most importantly set_dynamic_debug() and check_result(). The
|
||||
latter function greps the kernel's ring buffer for "livepatch:" and
|
||||
"test_klp" strings, so tests be sure to include one of those strings for
|
||||
result comparison. Other utility functions include general module
|
||||
loading and livepatch loading helpers (waiting for patch transitions,
|
||||
sysfs entries, etc.)
|
||||
@@ -0,0 +1 @@
|
||||
CONFIG_TEST_LIVEPATCH=m
|
||||
@@ -0,0 +1,203 @@
|
||||
#!/bin/bash
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
# Copyright (C) 2018 Joe Lawrence <joe.lawrence@redhat.com>
|
||||
|
||||
# Shell functions for the rest of the scripts.
|
||||
|
||||
MAX_RETRIES=600
|
||||
RETRY_INTERVAL=".1" # seconds
|
||||
|
||||
# log(msg) - write message to kernel log
|
||||
# msg - insightful words
|
||||
function log() {
|
||||
echo "$1" > /dev/kmsg
|
||||
}
|
||||
|
||||
# die(msg) - game over, man
|
||||
# msg - dying words
|
||||
function die() {
|
||||
log "ERROR: $1"
|
||||
echo "ERROR: $1" >&2
|
||||
exit 1
|
||||
}
|
||||
|
||||
# set_dynamic_debug() - setup kernel dynamic debug
|
||||
# TODO - push and pop this config?
|
||||
function set_dynamic_debug() {
|
||||
cat << EOF > /sys/kernel/debug/dynamic_debug/control
|
||||
file kernel/livepatch/* +p
|
||||
func klp_try_switch_task -p
|
||||
EOF
|
||||
}
|
||||
|
||||
# loop_until(cmd) - loop a command until it is successful or $MAX_RETRIES,
|
||||
# sleep $RETRY_INTERVAL between attempts
|
||||
# cmd - command and its arguments to run
|
||||
function loop_until() {
|
||||
local cmd="$*"
|
||||
local i=0
|
||||
while true; do
|
||||
eval "$cmd" && return 0
|
||||
[[ $((i++)) -eq $MAX_RETRIES ]] && return 1
|
||||
sleep $RETRY_INTERVAL
|
||||
done
|
||||
}
|
||||
|
||||
function is_livepatch_mod() {
|
||||
local mod="$1"
|
||||
|
||||
if [[ $(modinfo "$mod" | awk '/^livepatch:/{print $NF}') == "Y" ]]; then
|
||||
return 0
|
||||
fi
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
function __load_mod() {
|
||||
local mod="$1"; shift
|
||||
local args="$*"
|
||||
|
||||
local msg="% modprobe $mod $args"
|
||||
log "${msg%% }"
|
||||
ret=$(modprobe "$mod" "$args" 2>&1)
|
||||
if [[ "$ret" != "" ]]; then
|
||||
die "$ret"
|
||||
fi
|
||||
|
||||
# Wait for module in sysfs ...
|
||||
loop_until '[[ -e "/sys/module/$mod" ]]' ||
|
||||
die "failed to load module $mod"
|
||||
}
|
||||
|
||||
|
||||
# load_mod(modname, params) - load a kernel module
|
||||
# modname - module name to load
|
||||
# params - module parameters to pass to modprobe
|
||||
function load_mod() {
|
||||
local mod="$1"; shift
|
||||
local args="$*"
|
||||
|
||||
is_livepatch_mod "$mod" &&
|
||||
die "use load_lp() to load the livepatch module $mod"
|
||||
|
||||
__load_mod "$mod" "$args"
|
||||
}
|
||||
|
||||
# load_lp_nowait(modname, params) - load a kernel module with a livepatch
|
||||
# but do not wait on until the transition finishes
|
||||
# modname - module name to load
|
||||
# params - module parameters to pass to modprobe
|
||||
function load_lp_nowait() {
|
||||
local mod="$1"; shift
|
||||
local args="$*"
|
||||
|
||||
is_livepatch_mod "$mod" ||
|
||||
die "module $mod is not a livepatch"
|
||||
|
||||
__load_mod "$mod" "$args"
|
||||
|
||||
# Wait for livepatch in sysfs ...
|
||||
loop_until '[[ -e "/sys/kernel/livepatch/$mod" ]]' ||
|
||||
die "failed to load module $mod (sysfs)"
|
||||
}
|
||||
|
||||
# load_lp(modname, params) - load a kernel module with a livepatch
|
||||
# modname - module name to load
|
||||
# params - module parameters to pass to modprobe
|
||||
function load_lp() {
|
||||
local mod="$1"; shift
|
||||
local args="$*"
|
||||
|
||||
load_lp_nowait "$mod" "$args"
|
||||
|
||||
# Wait until the transition finishes ...
|
||||
loop_until 'grep -q '^0$' /sys/kernel/livepatch/$mod/transition' ||
|
||||
die "failed to complete transition"
|
||||
}
|
||||
|
||||
# load_failing_mod(modname, params) - load a kernel module, expect to fail
|
||||
# modname - module name to load
|
||||
# params - module parameters to pass to modprobe
|
||||
function load_failing_mod() {
|
||||
local mod="$1"; shift
|
||||
local args="$*"
|
||||
|
||||
local msg="% modprobe $mod $args"
|
||||
log "${msg%% }"
|
||||
ret=$(modprobe "$mod" "$args" 2>&1)
|
||||
if [[ "$ret" == "" ]]; then
|
||||
die "$mod unexpectedly loaded"
|
||||
fi
|
||||
log "$ret"
|
||||
}
|
||||
|
||||
# unload_mod(modname) - unload a kernel module
|
||||
# modname - module name to unload
|
||||
function unload_mod() {
|
||||
local mod="$1"
|
||||
|
||||
# Wait for module reference count to clear ...
|
||||
loop_until '[[ $(cat "/sys/module/$mod/refcnt") == "0" ]]' ||
|
||||
die "failed to unload module $mod (refcnt)"
|
||||
|
||||
log "% rmmod $mod"
|
||||
ret=$(rmmod "$mod" 2>&1)
|
||||
if [[ "$ret" != "" ]]; then
|
||||
die "$ret"
|
||||
fi
|
||||
|
||||
# Wait for module in sysfs ...
|
||||
loop_until '[[ ! -e "/sys/module/$mod" ]]' ||
|
||||
die "failed to unload module $mod (/sys/module)"
|
||||
}
|
||||
|
||||
# unload_lp(modname) - unload a kernel module with a livepatch
|
||||
# modname - module name to unload
|
||||
function unload_lp() {
|
||||
unload_mod "$1"
|
||||
}
|
||||
|
||||
# disable_lp(modname) - disable a livepatch
|
||||
# modname - module name to unload
|
||||
function disable_lp() {
|
||||
local mod="$1"
|
||||
|
||||
log "% echo 0 > /sys/kernel/livepatch/$mod/enabled"
|
||||
echo 0 > /sys/kernel/livepatch/"$mod"/enabled
|
||||
|
||||
# Wait until the transition finishes and the livepatch gets
|
||||
# removed from sysfs...
|
||||
loop_until '[[ ! -e "/sys/kernel/livepatch/$mod" ]]' ||
|
||||
die "failed to disable livepatch $mod"
|
||||
}
|
||||
|
||||
# set_pre_patch_ret(modname, pre_patch_ret)
|
||||
# modname - module name to set
|
||||
# pre_patch_ret - new pre_patch_ret value
|
||||
function set_pre_patch_ret {
|
||||
local mod="$1"; shift
|
||||
local ret="$1"
|
||||
|
||||
log "% echo $ret > /sys/module/$mod/parameters/pre_patch_ret"
|
||||
echo "$ret" > /sys/module/"$mod"/parameters/pre_patch_ret
|
||||
|
||||
# Wait for sysfs value to hold ...
|
||||
loop_until '[[ $(cat "/sys/module/$mod/parameters/pre_patch_ret") == "$ret" ]]' ||
|
||||
die "failed to set pre_patch_ret parameter for $mod module"
|
||||
}
|
||||
|
||||
# check_result() - verify dmesg output
|
||||
# TODO - better filter, out of order msgs, etc?
|
||||
function check_result {
|
||||
local expect="$*"
|
||||
local result
|
||||
|
||||
result=$(dmesg | grep -v 'tainting' | grep -e 'livepatch:' -e 'test_klp' | sed 's/^\[[ 0-9.]*\] //')
|
||||
|
||||
if [[ "$expect" == "$result" ]] ; then
|
||||
echo "ok"
|
||||
else
|
||||
echo -e "not ok\n\n$(diff -upr --label expected --label result <(echo "$expect") <(echo "$result"))\n"
|
||||
die "livepatch kselftest(s) failed"
|
||||
fi
|
||||
}
|
||||
+587
@@ -0,0 +1,587 @@
|
||||
#!/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
|
||||
|
||||
set_dynamic_debug
|
||||
|
||||
|
||||
# TEST: target module before livepatch
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: target module before livepatch ... "
|
||||
dmesg -C
|
||||
|
||||
load_mod $MOD_TARGET
|
||||
load_lp $MOD_LIVEPATCH
|
||||
disable_lp $MOD_LIVEPATCH
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
unload_mod $MOD_TARGET
|
||||
|
||||
check_result "% modprobe $MOD_TARGET
|
||||
$MOD_TARGET: ${MOD_TARGET}_init
|
||||
% modprobe $MOD_LIVEPATCH
|
||||
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"
|
||||
|
||||
|
||||
# TEST: module_coming notifier
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: module_coming notifier ... "
|
||||
dmesg -C
|
||||
|
||||
load_lp $MOD_LIVEPATCH
|
||||
load_mod $MOD_TARGET
|
||||
disable_lp $MOD_LIVEPATCH
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
unload_mod $MOD_TARGET
|
||||
|
||||
check_result "% modprobe $MOD_LIVEPATCH
|
||||
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
|
||||
% modprobe $MOD_TARGET
|
||||
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: module_going notifier
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: module_going notifier ... "
|
||||
dmesg -C
|
||||
|
||||
load_mod $MOD_TARGET
|
||||
load_lp $MOD_LIVEPATCH
|
||||
unload_mod $MOD_TARGET
|
||||
disable_lp $MOD_LIVEPATCH
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
|
||||
check_result "% modprobe $MOD_TARGET
|
||||
$MOD_TARGET: ${MOD_TARGET}_init
|
||||
% modprobe $MOD_LIVEPATCH
|
||||
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"
|
||||
|
||||
|
||||
# TEST: module_coming and module_going notifiers
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: module_coming and module_going notifiers ... "
|
||||
dmesg -C
|
||||
|
||||
load_lp $MOD_LIVEPATCH
|
||||
load_mod $MOD_TARGET
|
||||
unload_mod $MOD_TARGET
|
||||
disable_lp $MOD_LIVEPATCH
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
|
||||
check_result "% modprobe $MOD_LIVEPATCH
|
||||
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
|
||||
% modprobe $MOD_TARGET
|
||||
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"
|
||||
|
||||
|
||||
# TEST: target module not present
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: target module not present ... "
|
||||
dmesg -C
|
||||
|
||||
load_lp $MOD_LIVEPATCH
|
||||
disable_lp $MOD_LIVEPATCH
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
|
||||
check_result "% modprobe $MOD_LIVEPATCH
|
||||
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: pre-patch callback -ENODEV
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: pre-patch callback -ENODEV ... "
|
||||
dmesg -C
|
||||
|
||||
load_mod $MOD_TARGET
|
||||
load_failing_mod $MOD_LIVEPATCH pre_patch_ret=-19
|
||||
unload_mod $MOD_TARGET
|
||||
|
||||
check_result "% modprobe $MOD_TARGET
|
||||
$MOD_TARGET: ${MOD_TARGET}_init
|
||||
% modprobe $MOD_LIVEPATCH 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
|
||||
modprobe: ERROR: could not insert '$MOD_LIVEPATCH': No such device
|
||||
% rmmod $MOD_TARGET
|
||||
$MOD_TARGET: ${MOD_TARGET}_exit"
|
||||
|
||||
|
||||
# TEST: module_coming + pre-patch callback -ENODEV
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: module_coming + pre-patch callback -ENODEV ... "
|
||||
dmesg -C
|
||||
|
||||
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 "% modprobe $MOD_LIVEPATCH
|
||||
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
|
||||
% modprobe $MOD_TARGET
|
||||
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'
|
||||
modprobe: ERROR: could not insert '$MOD_TARGET': 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: multiple target modules
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: multiple target modules ... "
|
||||
dmesg -C
|
||||
|
||||
load_mod $MOD_TARGET_BUSY sleep_secs=0
|
||||
# give $MOD_TARGET_BUSY::busymod_work_func() a chance to run
|
||||
sleep 5
|
||||
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 "% modprobe $MOD_TARGET_BUSY sleep_secs=0
|
||||
$MOD_TARGET_BUSY: ${MOD_TARGET_BUSY}_init
|
||||
$MOD_TARGET_BUSY: busymod_work_func, sleeping 0 seconds ...
|
||||
$MOD_TARGET_BUSY: busymod_work_func exit
|
||||
% modprobe $MOD_LIVEPATCH
|
||||
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
|
||||
% modprobe $MOD_TARGET
|
||||
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"
|
||||
|
||||
|
||||
|
||||
# TEST: busy target module
|
||||
#
|
||||
# A similar test as the previous one, but force the "busy" kernel module
|
||||
# to do longer work.
|
||||
#
|
||||
# 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 it do 10 seconds worth
|
||||
# of work.
|
||||
#
|
||||
# - 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.
|
||||
|
||||
echo -n "TEST: busy target module ... "
|
||||
dmesg -C
|
||||
|
||||
load_mod $MOD_TARGET_BUSY sleep_secs=10
|
||||
load_lp_nowait $MOD_LIVEPATCH
|
||||
# Don't wait for transition, load $MOD_TARGET while the transition
|
||||
# is still stalled in $MOD_TARGET_BUSY::busymod_work_func()
|
||||
sleep 5
|
||||
load_mod $MOD_TARGET
|
||||
unload_mod $MOD_TARGET
|
||||
disable_lp $MOD_LIVEPATCH
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
unload_mod $MOD_TARGET_BUSY
|
||||
|
||||
check_result "% modprobe $MOD_TARGET_BUSY sleep_secs=10
|
||||
$MOD_TARGET_BUSY: ${MOD_TARGET_BUSY}_init
|
||||
$MOD_TARGET_BUSY: busymod_work_func, sleeping 10 seconds ...
|
||||
% modprobe $MOD_LIVEPATCH
|
||||
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
|
||||
% modprobe $MOD_TARGET
|
||||
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: multiple livepatches
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: multiple livepatches ... "
|
||||
dmesg -C
|
||||
|
||||
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 "% modprobe $MOD_LIVEPATCH
|
||||
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
|
||||
% modprobe $MOD_LIVEPATCH2
|
||||
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"
|
||||
|
||||
|
||||
# TEST: atomic replace
|
||||
#
|
||||
# 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.
|
||||
|
||||
echo -n "TEST: atomic replace ... "
|
||||
dmesg -C
|
||||
|
||||
load_lp $MOD_LIVEPATCH
|
||||
load_lp $MOD_LIVEPATCH2 replace=1
|
||||
disable_lp $MOD_LIVEPATCH2
|
||||
unload_lp $MOD_LIVEPATCH2
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
|
||||
check_result "% modprobe $MOD_LIVEPATCH
|
||||
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
|
||||
% modprobe $MOD_LIVEPATCH2 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
|
||||
+168
@@ -0,0 +1,168 @@
|
||||
#!/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_livepatch
|
||||
MOD_REPLACE=test_klp_atomic_replace
|
||||
|
||||
set_dynamic_debug
|
||||
|
||||
|
||||
# TEST: basic function patching
|
||||
# - load a livepatch that modifies the output from /proc/cmdline and
|
||||
# verify correct behavior
|
||||
# - unload the livepatch and make sure the patch was removed
|
||||
|
||||
echo -n "TEST: basic function patching ... "
|
||||
dmesg -C
|
||||
|
||||
load_lp $MOD_LIVEPATCH
|
||||
|
||||
if [[ "$(cat /proc/cmdline)" != "$MOD_LIVEPATCH: this has been live patched" ]] ; then
|
||||
echo -e "FAIL\n\n"
|
||||
die "livepatch kselftest(s) failed"
|
||||
fi
|
||||
|
||||
disable_lp $MOD_LIVEPATCH
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
|
||||
if [[ "$(cat /proc/cmdline)" == "$MOD_LIVEPATCH: this has been live patched" ]] ; then
|
||||
echo -e "FAIL\n\n"
|
||||
die "livepatch kselftest(s) failed"
|
||||
fi
|
||||
|
||||
check_result "% modprobe $MOD_LIVEPATCH
|
||||
livepatch: enabling patch '$MOD_LIVEPATCH'
|
||||
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': patching complete
|
||||
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
||||
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
||||
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
||||
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
||||
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
||||
% rmmod $MOD_LIVEPATCH"
|
||||
|
||||
|
||||
# TEST: multiple livepatches
|
||||
# - load a livepatch that modifies the output from /proc/cmdline and
|
||||
# verify correct behavior
|
||||
# - load another livepatch and verify that both livepatches are active
|
||||
# - unload the second livepatch and verify that the first is still active
|
||||
# - unload the first livepatch and verify none are active
|
||||
|
||||
echo -n "TEST: multiple livepatches ... "
|
||||
dmesg -C
|
||||
|
||||
load_lp $MOD_LIVEPATCH
|
||||
|
||||
grep 'live patched' /proc/cmdline > /dev/kmsg
|
||||
grep 'live patched' /proc/meminfo > /dev/kmsg
|
||||
|
||||
load_lp $MOD_REPLACE replace=0
|
||||
|
||||
grep 'live patched' /proc/cmdline > /dev/kmsg
|
||||
grep 'live patched' /proc/meminfo > /dev/kmsg
|
||||
|
||||
disable_lp $MOD_REPLACE
|
||||
unload_lp $MOD_REPLACE
|
||||
|
||||
grep 'live patched' /proc/cmdline > /dev/kmsg
|
||||
grep 'live patched' /proc/meminfo > /dev/kmsg
|
||||
|
||||
disable_lp $MOD_LIVEPATCH
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
|
||||
grep 'live patched' /proc/cmdline > /dev/kmsg
|
||||
grep 'live patched' /proc/meminfo > /dev/kmsg
|
||||
|
||||
check_result "% modprobe $MOD_LIVEPATCH
|
||||
livepatch: enabling patch '$MOD_LIVEPATCH'
|
||||
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': patching complete
|
||||
$MOD_LIVEPATCH: this has been live patched
|
||||
% modprobe $MOD_REPLACE replace=0
|
||||
livepatch: enabling patch '$MOD_REPLACE'
|
||||
livepatch: '$MOD_REPLACE': initializing patching transition
|
||||
livepatch: '$MOD_REPLACE': starting patching transition
|
||||
livepatch: '$MOD_REPLACE': completing patching transition
|
||||
livepatch: '$MOD_REPLACE': patching complete
|
||||
$MOD_LIVEPATCH: this has been live patched
|
||||
$MOD_REPLACE: this has been live patched
|
||||
% echo 0 > /sys/kernel/livepatch/$MOD_REPLACE/enabled
|
||||
livepatch: '$MOD_REPLACE': initializing unpatching transition
|
||||
livepatch: '$MOD_REPLACE': starting unpatching transition
|
||||
livepatch: '$MOD_REPLACE': completing unpatching transition
|
||||
livepatch: '$MOD_REPLACE': unpatching complete
|
||||
% rmmod $MOD_REPLACE
|
||||
$MOD_LIVEPATCH: this has been live patched
|
||||
% echo 0 > /sys/kernel/livepatch/$MOD_LIVEPATCH/enabled
|
||||
livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
|
||||
livepatch: '$MOD_LIVEPATCH': starting unpatching transition
|
||||
livepatch: '$MOD_LIVEPATCH': completing unpatching transition
|
||||
livepatch: '$MOD_LIVEPATCH': unpatching complete
|
||||
% rmmod $MOD_LIVEPATCH"
|
||||
|
||||
|
||||
# TEST: atomic replace livepatch
|
||||
# - load a livepatch that modifies the output from /proc/cmdline and
|
||||
# verify correct behavior
|
||||
# - load an atomic replace livepatch and verify that only the second is active
|
||||
# - remove the first livepatch and verify that the atomic replace livepatch
|
||||
# is still active
|
||||
# - remove the atomic replace livepatch and verify that none are active
|
||||
|
||||
echo -n "TEST: atomic replace livepatch ... "
|
||||
dmesg -C
|
||||
|
||||
load_lp $MOD_LIVEPATCH
|
||||
|
||||
grep 'live patched' /proc/cmdline > /dev/kmsg
|
||||
grep 'live patched' /proc/meminfo > /dev/kmsg
|
||||
|
||||
load_lp $MOD_REPLACE replace=1
|
||||
|
||||
grep 'live patched' /proc/cmdline > /dev/kmsg
|
||||
grep 'live patched' /proc/meminfo > /dev/kmsg
|
||||
|
||||
unload_lp $MOD_LIVEPATCH
|
||||
|
||||
grep 'live patched' /proc/cmdline > /dev/kmsg
|
||||
grep 'live patched' /proc/meminfo > /dev/kmsg
|
||||
|
||||
disable_lp $MOD_REPLACE
|
||||
unload_lp $MOD_REPLACE
|
||||
|
||||
grep 'live patched' /proc/cmdline > /dev/kmsg
|
||||
grep 'live patched' /proc/meminfo > /dev/kmsg
|
||||
|
||||
check_result "% modprobe $MOD_LIVEPATCH
|
||||
livepatch: enabling patch '$MOD_LIVEPATCH'
|
||||
livepatch: '$MOD_LIVEPATCH': initializing patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': starting patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': completing patching transition
|
||||
livepatch: '$MOD_LIVEPATCH': patching complete
|
||||
$MOD_LIVEPATCH: this has been live patched
|
||||
% modprobe $MOD_REPLACE replace=1
|
||||
livepatch: enabling patch '$MOD_REPLACE'
|
||||
livepatch: '$MOD_REPLACE': initializing patching transition
|
||||
livepatch: '$MOD_REPLACE': starting patching transition
|
||||
livepatch: '$MOD_REPLACE': completing patching transition
|
||||
livepatch: '$MOD_REPLACE': patching complete
|
||||
$MOD_REPLACE: this has been live patched
|
||||
% rmmod $MOD_LIVEPATCH
|
||||
$MOD_REPLACE: this has been live patched
|
||||
% echo 0 > /sys/kernel/livepatch/$MOD_REPLACE/enabled
|
||||
livepatch: '$MOD_REPLACE': initializing unpatching transition
|
||||
livepatch: '$MOD_REPLACE': starting unpatching transition
|
||||
livepatch: '$MOD_REPLACE': completing unpatching transition
|
||||
livepatch: '$MOD_REPLACE': unpatching complete
|
||||
% rmmod $MOD_REPLACE"
|
||||
|
||||
|
||||
exit 0
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
#!/bin/bash
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
# Copyright (C) 2018 Joe Lawrence <joe.lawrence@redhat.com>
|
||||
|
||||
. $(dirname $0)/functions.sh
|
||||
|
||||
MOD_TEST=test_klp_shadow_vars
|
||||
|
||||
set_dynamic_debug
|
||||
|
||||
|
||||
# TEST: basic shadow variable API
|
||||
# - load a module that exercises the shadow variable API
|
||||
|
||||
echo -n "TEST: basic shadow variable API ... "
|
||||
dmesg -C
|
||||
|
||||
load_mod $MOD_TEST
|
||||
unload_mod $MOD_TEST
|
||||
|
||||
check_result "% modprobe $MOD_TEST
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR5, id=0x1234) = PTR0
|
||||
$MOD_TEST: got expected NULL result
|
||||
$MOD_TEST: shadow_ctor: PTR6 -> PTR1
|
||||
$MOD_TEST: klp_shadow_alloc(obj=PTR5, id=0x1234, size=8, gfp_flags=GFP_KERNEL), ctor=PTR7, ctor_data=PTR1 = PTR6
|
||||
$MOD_TEST: shadow_ctor: PTR8 -> PTR2
|
||||
$MOD_TEST: klp_shadow_alloc(obj=PTR9, id=0x1234, size=8, gfp_flags=GFP_KERNEL), ctor=PTR7, ctor_data=PTR2 = PTR8
|
||||
$MOD_TEST: shadow_ctor: PTR10 -> PTR3
|
||||
$MOD_TEST: klp_shadow_alloc(obj=PTR5, id=0x1235, size=8, gfp_flags=GFP_KERNEL), ctor=PTR7, ctor_data=PTR3 = PTR10
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR5, id=0x1234) = PTR6
|
||||
$MOD_TEST: got expected PTR6 -> PTR1 result
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR9, id=0x1234) = PTR8
|
||||
$MOD_TEST: got expected PTR8 -> PTR2 result
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR5, id=0x1235) = PTR10
|
||||
$MOD_TEST: got expected PTR10 -> PTR3 result
|
||||
$MOD_TEST: shadow_ctor: PTR11 -> PTR4
|
||||
$MOD_TEST: klp_shadow_get_or_alloc(obj=PTR12, id=0x1234, size=8, gfp_flags=GFP_KERNEL), ctor=PTR7, ctor_data=PTR4 = PTR11
|
||||
$MOD_TEST: klp_shadow_get_or_alloc(obj=PTR12, id=0x1234, size=8, gfp_flags=GFP_KERNEL), ctor=PTR7, ctor_data=PTR4 = PTR11
|
||||
$MOD_TEST: got expected PTR11 -> PTR4 result
|
||||
$MOD_TEST: shadow_dtor(obj=PTR5, shadow_data=PTR6)
|
||||
$MOD_TEST: klp_shadow_free(obj=PTR5, id=0x1234, dtor=PTR13)
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR5, id=0x1234) = PTR0
|
||||
$MOD_TEST: got expected NULL result
|
||||
$MOD_TEST: shadow_dtor(obj=PTR9, shadow_data=PTR8)
|
||||
$MOD_TEST: klp_shadow_free(obj=PTR9, id=0x1234, dtor=PTR13)
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR9, id=0x1234) = PTR0
|
||||
$MOD_TEST: got expected NULL result
|
||||
$MOD_TEST: shadow_dtor(obj=PTR12, shadow_data=PTR11)
|
||||
$MOD_TEST: klp_shadow_free(obj=PTR12, id=0x1234, dtor=PTR13)
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR12, id=0x1234) = PTR0
|
||||
$MOD_TEST: got expected NULL result
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR5, id=0x1235) = PTR10
|
||||
$MOD_TEST: got expected PTR10 -> PTR3 result
|
||||
$MOD_TEST: shadow_dtor(obj=PTR5, shadow_data=PTR10)
|
||||
$MOD_TEST: klp_shadow_free_all(id=0x1235, dtor=PTR13)
|
||||
$MOD_TEST: klp_shadow_get(obj=PTR5, id=0x1234) = PTR0
|
||||
$MOD_TEST: shadow_get() got expected NULL result
|
||||
% rmmod test_klp_shadow_vars"
|
||||
|
||||
exit 0
|
||||
Reference in New Issue
Block a user